| 1 | /* |
| 2 | * Copyright (C) 2013 Google Inc. All rights reserved. |
| 3 | * Copyright (C) 2013-2016 Apple Inc. All rights reserved. |
| 4 | * Copyright (C) 2014 University of Washington. All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions |
| 8 | * are met: |
| 9 | * 1. Redistributions of source code must retain the above copyright |
| 10 | * notice, this list of conditions and the following disclaimer. |
| 11 | * 2. Redistributions in binary form must reproduce the above copyright |
| 12 | * notice, this list of conditions and the following disclaimer in the |
| 13 | * documentation and/or other materials provided with the distribution. |
| 14 | * |
| 15 | * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' |
| 16 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
| 17 | * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| 18 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS |
| 19 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| 20 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| 21 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| 22 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| 23 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| 24 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
| 25 | * THE POSSIBILITY OF SUCH DAMAGE. |
| 26 | */ |
| 27 | |
| 28 | // DO NOT EDIT THIS FILE. It is automatically generated from CombinedDomains.json by the script: Source/JavaScriptCore/inspector/scripts/generate-inspector-protocol-bindings.py |
| 29 | |
| 30 | #pragma once |
| 31 | |
| 32 | #include "InspectorProtocolTypes.h" |
| 33 | #include <wtf/JSONValues.h> |
| 34 | #include <wtf/text/WTFString.h> |
| 35 | |
| 36 | namespace Inspector { |
| 37 | |
| 38 | |
| 39 | |
| 40 | namespace Protocol { |
| 41 | |
| 42 | // Versions. |
| 43 | namespace Audit { |
| 44 | static constexpr unsigned VERSION = 3; |
| 45 | } // Audit |
| 46 | |
| 47 | namespace Recording { |
| 48 | static constexpr unsigned VERSION = 1; |
| 49 | } // Recording |
| 50 | // End of versions. |
| 51 | |
| 52 | |
| 53 | // Forward declarations. |
| 54 | namespace Animation { |
| 55 | class Animation; |
| 56 | class Effect; |
| 57 | class Keyframe; |
| 58 | class TrackingUpdate; |
| 59 | enum class AnimationState; |
| 60 | enum class PlaybackDirection; |
| 61 | enum class FillMode; |
| 62 | } // Animation |
| 63 | |
| 64 | namespace ApplicationCache { |
| 65 | class ApplicationCacheResource; |
| 66 | class ApplicationCache; |
| 67 | class FrameWithManifest; |
| 68 | } // ApplicationCache |
| 69 | |
| 70 | namespace Browser { |
| 71 | class Extension; |
| 72 | } // Browser |
| 73 | |
| 74 | #if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 75 | namespace CPUProfiler { |
| 76 | class ThreadInfo; |
| 77 | class Event; |
| 78 | } // CPUProfiler |
| 79 | #endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 80 | |
| 81 | namespace CSS { |
| 82 | class CSSStyleId; |
| 83 | class CSSRuleId; |
| 84 | class PseudoIdMatches; |
| 85 | class InheritedStyleEntry; |
| 86 | class RuleMatch; |
| 87 | class CSSSelector; |
| 88 | class SelectorList; |
| 89 | class CSSStyleAttribute; |
| 90 | class CSSStyleSheetHeader; |
| 91 | class CSSStyleSheetBody; |
| 92 | class CSSRule; |
| 93 | class SourceRange; |
| 94 | class ShorthandEntry; |
| 95 | class CSSPropertyInfo; |
| 96 | class CSSComputedStyleProperty; |
| 97 | class CSSStyle; |
| 98 | class CSSProperty; |
| 99 | class Grouping; |
| 100 | class Font; |
| 101 | class FontVariationAxis; |
| 102 | enum class StyleSheetOrigin; |
| 103 | enum class PseudoId; |
| 104 | enum class CSSPropertyStatus; |
| 105 | enum class LayoutContextType; |
| 106 | enum class LayoutContextTypeChangedMode; |
| 107 | } // CSS |
| 108 | |
| 109 | namespace Canvas { |
| 110 | class ContextAttributes; |
| 111 | class Canvas; |
| 112 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 113 | class ShaderProgram; |
| 114 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 115 | enum class ContextType; |
| 116 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 117 | enum class ProgramType; |
| 118 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 119 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 120 | enum class ShaderType; |
| 121 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 122 | } // Canvas |
| 123 | |
| 124 | namespace Console { |
| 125 | class Channel; |
| 126 | class ConsoleMessage; |
| 127 | class CallFrame; |
| 128 | class StackTrace; |
| 129 | enum class ChannelSource; |
| 130 | enum class ChannelLevel; |
| 131 | } // Console |
| 132 | |
| 133 | namespace DOM { |
| 134 | class Node; |
| 135 | class DataBinding; |
| 136 | class EventListener; |
| 137 | class AccessibilityProperties; |
| 138 | class RGBAColor; |
| 139 | class HighlightConfig; |
| 140 | enum class PseudoType; |
| 141 | enum class ShadowRootType; |
| 142 | enum class CustomElementState; |
| 143 | enum class LiveRegionRelevant; |
| 144 | } // DOM |
| 145 | |
| 146 | namespace DOMDebugger { |
| 147 | enum class DOMBreakpointType; |
| 148 | enum class EventBreakpointType; |
| 149 | } // DOMDebugger |
| 150 | |
| 151 | namespace DOMStorage { |
| 152 | class StorageId; |
| 153 | } // DOMStorage |
| 154 | |
| 155 | namespace Database { |
| 156 | class Database; |
| 157 | class Error; |
| 158 | } // Database |
| 159 | |
| 160 | namespace Debugger { |
| 161 | class Location; |
| 162 | class BreakpointAction; |
| 163 | class BreakpointOptions; |
| 164 | class FunctionDetails; |
| 165 | class CallFrame; |
| 166 | class Scope; |
| 167 | class ProbeSample; |
| 168 | class AssertPauseReason; |
| 169 | class BreakpointPauseReason; |
| 170 | class CSPViolationPauseReason; |
| 171 | } // Debugger |
| 172 | |
| 173 | namespace GenericTypes { |
| 174 | class SearchMatch; |
| 175 | } // GenericTypes |
| 176 | |
| 177 | namespace Heap { |
| 178 | class GarbageCollection; |
| 179 | } // Heap |
| 180 | |
| 181 | namespace IndexedDB { |
| 182 | class DatabaseWithObjectStores; |
| 183 | class ObjectStore; |
| 184 | class ObjectStoreIndex; |
| 185 | class Key; |
| 186 | class KeyRange; |
| 187 | class DataEntry; |
| 188 | class KeyPath; |
| 189 | } // IndexedDB |
| 190 | |
| 191 | namespace LayerTree { |
| 192 | class IntRect; |
| 193 | class Layer; |
| 194 | class CompositingReasons; |
| 195 | } // LayerTree |
| 196 | |
| 197 | #if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 198 | namespace Memory { |
| 199 | class Event; |
| 200 | class CategoryData; |
| 201 | } // Memory |
| 202 | #endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 203 | |
| 204 | namespace Network { |
| 205 | class Headers; |
| 206 | class ResourceTiming; |
| 207 | class Request; |
| 208 | class Response; |
| 209 | class Metrics; |
| 210 | class WebSocketRequest; |
| 211 | class WebSocketResponse; |
| 212 | class WebSocketFrame; |
| 213 | class CachedResource; |
| 214 | class Initiator; |
| 215 | enum class NetworkStage; |
| 216 | enum class ResourceErrorType; |
| 217 | } // Network |
| 218 | |
| 219 | namespace Page { |
| 220 | class Frame; |
| 221 | class FrameResource; |
| 222 | class FrameResourceTree; |
| 223 | class SearchResult; |
| 224 | class Cookie; |
| 225 | enum class Setting; |
| 226 | enum class ResourceType; |
| 227 | enum class CoordinateSystem; |
| 228 | enum class CookieSameSitePolicy; |
| 229 | #if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 230 | enum class Appearance; |
| 231 | #endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 232 | } // Page |
| 233 | |
| 234 | namespace Recording { |
| 235 | class InitialState; |
| 236 | class Frame; |
| 237 | class Recording; |
| 238 | enum class Type; |
| 239 | enum class Initiator; |
| 240 | } // Recording |
| 241 | |
| 242 | namespace Runtime { |
| 243 | class RemoteObject; |
| 244 | class ObjectPreview; |
| 245 | class PropertyPreview; |
| 246 | class EntryPreview; |
| 247 | class CollectionEntry; |
| 248 | class PropertyDescriptor; |
| 249 | class InternalPropertyDescriptor; |
| 250 | class CallArgument; |
| 251 | class ExecutionContextDescription; |
| 252 | class ErrorRange; |
| 253 | class StructureDescription; |
| 254 | class TypeSet; |
| 255 | class TypeDescription; |
| 256 | class TypeLocation; |
| 257 | class BasicBlock; |
| 258 | enum class ExecutionContextType; |
| 259 | enum class SyntaxErrorType; |
| 260 | } // Runtime |
| 261 | |
| 262 | namespace ScriptProfiler { |
| 263 | class Event; |
| 264 | class ExpressionLocation; |
| 265 | class StackFrame; |
| 266 | class StackTrace; |
| 267 | class Samples; |
| 268 | enum class EventType; |
| 269 | } // ScriptProfiler |
| 270 | |
| 271 | namespace Security { |
| 272 | class Connection; |
| 273 | class Certificate; |
| 274 | class Security; |
| 275 | } // Security |
| 276 | |
| 277 | #if defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER |
| 278 | namespace ServiceWorker { |
| 279 | class Configuration; |
| 280 | } // ServiceWorker |
| 281 | #endif // defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER |
| 282 | |
| 283 | namespace Target { |
| 284 | class TargetInfo; |
| 285 | } // Target |
| 286 | |
| 287 | namespace Timeline { |
| 288 | class TimelineEvent; |
| 289 | enum class EventType; |
| 290 | enum class Instrument; |
| 291 | } // Timeline |
| 292 | // End of forward declarations. |
| 293 | |
| 294 | |
| 295 | // Typedefs. |
| 296 | namespace Animation { |
| 297 | /* Unique Web Animation identifier. */ |
| 298 | using AnimationId = String; |
| 299 | } // Animation |
| 300 | |
| 301 | namespace Browser { |
| 302 | /* Unique extension identifier. */ |
| 303 | using ExtensionId = String; |
| 304 | } // Browser |
| 305 | |
| 306 | namespace CSS { |
| 307 | using StyleSheetId = String; |
| 308 | } // CSS |
| 309 | |
| 310 | namespace Canvas { |
| 311 | /* Unique canvas identifier. */ |
| 312 | using CanvasId = String; |
| 313 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 314 | /* Unique shader program identifier. */ |
| 315 | using ProgramId = String; |
| 316 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 317 | } // Canvas |
| 318 | |
| 319 | namespace DOM { |
| 320 | /* Unique DOM node identifier. */ |
| 321 | using NodeId = int; |
| 322 | /* Unique event listener identifier. */ |
| 323 | using EventListenerId = int; |
| 324 | /* An array of quad vertices, x immediately followed by y for each point, points clock-wise. */ |
| 325 | using Quad = JSON::ArrayOf<double>; |
| 326 | } // DOM |
| 327 | |
| 328 | namespace DOMStorage { |
| 329 | /* DOM Storage item. */ |
| 330 | using Item = JSON::ArrayOf<String>; |
| 331 | } // DOMStorage |
| 332 | |
| 333 | namespace Database { |
| 334 | /* Unique identifier of Database object. */ |
| 335 | using DatabaseId = String; |
| 336 | } // Database |
| 337 | |
| 338 | namespace Debugger { |
| 339 | /* Breakpoint identifier. */ |
| 340 | using BreakpointId = String; |
| 341 | /* Breakpoint action identifier. */ |
| 342 | using BreakpointActionIdentifier = int; |
| 343 | /* Unique script identifier. */ |
| 344 | using ScriptId = String; |
| 345 | /* Call frame identifier. */ |
| 346 | using CallFrameId = String; |
| 347 | } // Debugger |
| 348 | |
| 349 | namespace Heap { |
| 350 | /* JavaScriptCore HeapSnapshot JSON data. */ |
| 351 | using HeapSnapshotData = String; |
| 352 | } // Heap |
| 353 | |
| 354 | namespace LayerTree { |
| 355 | /* Unique RenderLayer identifier. */ |
| 356 | using LayerId = String; |
| 357 | /* Unique PseudoElement identifier. */ |
| 358 | using PseudoElementId = String; |
| 359 | } // LayerTree |
| 360 | |
| 361 | namespace Network { |
| 362 | /* Unique loader identifier. */ |
| 363 | using LoaderId = String; |
| 364 | /* Unique frame identifier. */ |
| 365 | using FrameId = String; |
| 366 | /* Unique request identifier. */ |
| 367 | using RequestId = String; |
| 368 | /* Elapsed seconds since frontend connected. */ |
| 369 | using Timestamp = double; |
| 370 | /* Number of seconds since epoch. */ |
| 371 | using Walltime = double; |
| 372 | } // Network |
| 373 | |
| 374 | namespace Runtime { |
| 375 | /* Unique object identifier. */ |
| 376 | using RemoteObjectId = String; |
| 377 | /* Id of an execution context. */ |
| 378 | using ExecutionContextId = int; |
| 379 | } // Runtime |
| 380 | // End of typedefs. |
| 381 | |
| 382 | namespace Helpers { |
| 383 | |
| 384 | JS_EXPORT_PRIVATE String getEnumConstantValue(int code); |
| 385 | |
| 386 | template<typename T> String getEnumConstantValue(T enumValue) |
| 387 | { |
| 388 | return getEnumConstantValue(static_cast<int>(enumValue)); |
| 389 | } |
| 390 | |
| 391 | } // namespace Helpers |
| 392 | |
| 393 | namespace Animation { |
| 394 | |
| 395 | enum class AnimationState { |
| 396 | Ready = 0, |
| 397 | Delayed = 1, |
| 398 | Active = 2, |
| 399 | Canceled = 3, |
| 400 | Done = 4, |
| 401 | }; // enum class AnimationState |
| 402 | |
| 403 | enum class PlaybackDirection { |
| 404 | Normal = 5, |
| 405 | Reverse = 6, |
| 406 | Alternate = 7, |
| 407 | AlternateReverse = 8, |
| 408 | }; // enum class PlaybackDirection |
| 409 | |
| 410 | enum class FillMode { |
| 411 | None = 9, |
| 412 | Forwards = 10, |
| 413 | Backwards = 11, |
| 414 | Both = 12, |
| 415 | Auto = 13, |
| 416 | }; // enum class FillMode |
| 417 | |
| 418 | class Animation final : public JSON::ObjectBase { |
| 419 | public: |
| 420 | enum { |
| 421 | NoFieldsSet = 0, |
| 422 | AnimationIdSet = 1 << 0, |
| 423 | AllFieldsSet = (AnimationIdSet) |
| 424 | }; |
| 425 | |
| 426 | template<int STATE> |
| 427 | class Builder { |
| 428 | private: |
| 429 | RefPtr<JSON::Object> m_result; |
| 430 | |
| 431 | template<int STEP> Builder<STATE | STEP>& castState() |
| 432 | { |
| 433 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 434 | } |
| 435 | |
| 436 | Builder(Ref</*Animation*/JSON::Object>&& object) |
| 437 | : m_result(WTFMove(object)) |
| 438 | { |
| 439 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 440 | } |
| 441 | friend class Animation; |
| 442 | public: |
| 443 | |
| 444 | Builder<STATE | AnimationIdSet>& setAnimationId(const String& in_animationId) |
| 445 | { |
| 446 | COMPILE_ASSERT(!(STATE & AnimationIdSet), property_animationId_already_set); |
| 447 | m_result->setString("animationId"_s , in_animationId); |
| 448 | return castState<AnimationIdSet>(); |
| 449 | } |
| 450 | |
| 451 | Ref<Animation> release() |
| 452 | { |
| 453 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 454 | COMPILE_ASSERT(sizeof(Animation) == sizeof(JSON::Object), cannot_cast); |
| 455 | |
| 456 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 457 | auto result = WTFMove(*reinterpret_cast<Ref<Animation>*>(&jsonResult)); |
| 458 | return result; |
| 459 | } |
| 460 | }; |
| 461 | |
| 462 | /* |
| 463 | * Synthetic constructor: |
| 464 | * Ref<Animation> result = Animation::create() |
| 465 | * .setAnimationId(...) |
| 466 | * .release(); |
| 467 | */ |
| 468 | static Builder<NoFieldsSet> create() |
| 469 | { |
| 470 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 471 | } |
| 472 | |
| 473 | void setName(const String& in_opt_name) |
| 474 | { |
| 475 | JSON::ObjectBase::setString("name"_s , in_opt_name); |
| 476 | } |
| 477 | |
| 478 | void setCssAnimationName(const String& in_opt_cssAnimationName) |
| 479 | { |
| 480 | JSON::ObjectBase::setString("cssAnimationName"_s , in_opt_cssAnimationName); |
| 481 | } |
| 482 | |
| 483 | void setCssTransitionProperty(const String& in_opt_cssTransitionProperty) |
| 484 | { |
| 485 | JSON::ObjectBase::setString("cssTransitionProperty"_s , in_opt_cssTransitionProperty); |
| 486 | } |
| 487 | |
| 488 | void setEffect(Ref<Protocol::Animation::Effect>&& in_opt_effect) |
| 489 | { |
| 490 | JSON::ObjectBase::setObject("effect"_s , WTFMove(in_opt_effect)); |
| 491 | } |
| 492 | |
| 493 | void setBacktrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_backtrace) |
| 494 | { |
| 495 | JSON::ObjectBase::setArray("backtrace"_s , WTFMove(in_opt_backtrace)); |
| 496 | } |
| 497 | }; |
| 498 | |
| 499 | class Effect final : public JSON::ObjectBase { |
| 500 | public: |
| 501 | enum { |
| 502 | NoFieldsSet = 0, |
| 503 | AllFieldsSet = 0 |
| 504 | }; |
| 505 | |
| 506 | template<int STATE> |
| 507 | class Builder { |
| 508 | private: |
| 509 | RefPtr<JSON::Object> m_result; |
| 510 | |
| 511 | template<int STEP> Builder<STATE | STEP>& castState() |
| 512 | { |
| 513 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 514 | } |
| 515 | |
| 516 | Builder(Ref</*Effect*/JSON::Object>&& object) |
| 517 | : m_result(WTFMove(object)) |
| 518 | { |
| 519 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 520 | } |
| 521 | friend class Effect; |
| 522 | public: |
| 523 | |
| 524 | Ref<Effect> release() |
| 525 | { |
| 526 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 527 | COMPILE_ASSERT(sizeof(Effect) == sizeof(JSON::Object), cannot_cast); |
| 528 | |
| 529 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 530 | auto result = WTFMove(*reinterpret_cast<Ref<Effect>*>(&jsonResult)); |
| 531 | return result; |
| 532 | } |
| 533 | }; |
| 534 | |
| 535 | /* |
| 536 | * Synthetic constructor: |
| 537 | * Ref<Effect> result = Effect::create() |
| 538 | * .release(); |
| 539 | */ |
| 540 | static Builder<NoFieldsSet> create() |
| 541 | { |
| 542 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 543 | } |
| 544 | |
| 545 | void setStartDelay(double in_opt_startDelay) |
| 546 | { |
| 547 | JSON::ObjectBase::setDouble("startDelay"_s , in_opt_startDelay); |
| 548 | } |
| 549 | |
| 550 | void setEndDelay(double in_opt_endDelay) |
| 551 | { |
| 552 | JSON::ObjectBase::setDouble("endDelay"_s , in_opt_endDelay); |
| 553 | } |
| 554 | |
| 555 | void setIterationCount(double in_opt_iterationCount) |
| 556 | { |
| 557 | JSON::ObjectBase::setDouble("iterationCount"_s , in_opt_iterationCount); |
| 558 | } |
| 559 | |
| 560 | void setIterationStart(double in_opt_iterationStart) |
| 561 | { |
| 562 | JSON::ObjectBase::setDouble("iterationStart"_s , in_opt_iterationStart); |
| 563 | } |
| 564 | |
| 565 | void setIterationDuration(double in_opt_iterationDuration) |
| 566 | { |
| 567 | JSON::ObjectBase::setDouble("iterationDuration"_s , in_opt_iterationDuration); |
| 568 | } |
| 569 | |
| 570 | void setTimingFunction(const String& in_opt_timingFunction) |
| 571 | { |
| 572 | JSON::ObjectBase::setString("timingFunction"_s , in_opt_timingFunction); |
| 573 | } |
| 574 | |
| 575 | void setPlaybackDirection(Protocol::Animation::PlaybackDirection in_opt_playbackDirection) |
| 576 | { |
| 577 | JSON::ObjectBase::setString("playbackDirection"_s , Protocol::Helpers::getEnumConstantValue(in_opt_playbackDirection)); |
| 578 | } |
| 579 | |
| 580 | void setFillMode(Protocol::Animation::FillMode in_opt_fillMode) |
| 581 | { |
| 582 | JSON::ObjectBase::setString("fillMode"_s , Protocol::Helpers::getEnumConstantValue(in_opt_fillMode)); |
| 583 | } |
| 584 | |
| 585 | void setKeyframes(Ref<JSON::ArrayOf<Protocol::Animation::Keyframe>>&& in_opt_keyframes) |
| 586 | { |
| 587 | JSON::ObjectBase::setArray("keyframes"_s , WTFMove(in_opt_keyframes)); |
| 588 | } |
| 589 | }; |
| 590 | |
| 591 | class Keyframe final : public JSON::ObjectBase { |
| 592 | public: |
| 593 | enum { |
| 594 | NoFieldsSet = 0, |
| 595 | OffsetSet = 1 << 0, |
| 596 | AllFieldsSet = (OffsetSet) |
| 597 | }; |
| 598 | |
| 599 | template<int STATE> |
| 600 | class Builder { |
| 601 | private: |
| 602 | RefPtr<JSON::Object> m_result; |
| 603 | |
| 604 | template<int STEP> Builder<STATE | STEP>& castState() |
| 605 | { |
| 606 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 607 | } |
| 608 | |
| 609 | Builder(Ref</*Keyframe*/JSON::Object>&& object) |
| 610 | : m_result(WTFMove(object)) |
| 611 | { |
| 612 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 613 | } |
| 614 | friend class Keyframe; |
| 615 | public: |
| 616 | |
| 617 | Builder<STATE | OffsetSet>& setOffset(double in_offset) |
| 618 | { |
| 619 | COMPILE_ASSERT(!(STATE & OffsetSet), property_offset_already_set); |
| 620 | m_result->setDouble("offset"_s , in_offset); |
| 621 | return castState<OffsetSet>(); |
| 622 | } |
| 623 | |
| 624 | Ref<Keyframe> release() |
| 625 | { |
| 626 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 627 | COMPILE_ASSERT(sizeof(Keyframe) == sizeof(JSON::Object), cannot_cast); |
| 628 | |
| 629 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 630 | auto result = WTFMove(*reinterpret_cast<Ref<Keyframe>*>(&jsonResult)); |
| 631 | return result; |
| 632 | } |
| 633 | }; |
| 634 | |
| 635 | /* |
| 636 | * Synthetic constructor: |
| 637 | * Ref<Keyframe> result = Keyframe::create() |
| 638 | * .setOffset(...) |
| 639 | * .release(); |
| 640 | */ |
| 641 | static Builder<NoFieldsSet> create() |
| 642 | { |
| 643 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 644 | } |
| 645 | |
| 646 | void setEasing(const String& in_opt_easing) |
| 647 | { |
| 648 | JSON::ObjectBase::setString("easing"_s , in_opt_easing); |
| 649 | } |
| 650 | |
| 651 | void setStyle(const String& in_opt_style) |
| 652 | { |
| 653 | JSON::ObjectBase::setString("style"_s , in_opt_style); |
| 654 | } |
| 655 | }; |
| 656 | |
| 657 | class TrackingUpdate final : public JSON::ObjectBase { |
| 658 | public: |
| 659 | enum { |
| 660 | NoFieldsSet = 0, |
| 661 | TrackingAnimationIdSet = 1 << 0, |
| 662 | AnimationStateSet = 1 << 1, |
| 663 | AllFieldsSet = (TrackingAnimationIdSet | AnimationStateSet) |
| 664 | }; |
| 665 | |
| 666 | template<int STATE> |
| 667 | class Builder { |
| 668 | private: |
| 669 | RefPtr<JSON::Object> m_result; |
| 670 | |
| 671 | template<int STEP> Builder<STATE | STEP>& castState() |
| 672 | { |
| 673 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 674 | } |
| 675 | |
| 676 | Builder(Ref</*TrackingUpdate*/JSON::Object>&& object) |
| 677 | : m_result(WTFMove(object)) |
| 678 | { |
| 679 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 680 | } |
| 681 | friend class TrackingUpdate; |
| 682 | public: |
| 683 | |
| 684 | Builder<STATE | TrackingAnimationIdSet>& setTrackingAnimationId(const String& in_trackingAnimationId) |
| 685 | { |
| 686 | COMPILE_ASSERT(!(STATE & TrackingAnimationIdSet), property_trackingAnimationId_already_set); |
| 687 | m_result->setString("trackingAnimationId"_s , in_trackingAnimationId); |
| 688 | return castState<TrackingAnimationIdSet>(); |
| 689 | } |
| 690 | |
| 691 | Builder<STATE | AnimationStateSet>& setAnimationState(Protocol::Animation::AnimationState in_animationState) |
| 692 | { |
| 693 | COMPILE_ASSERT(!(STATE & AnimationStateSet), property_animationState_already_set); |
| 694 | m_result->setString("animationState"_s , Protocol::Helpers::getEnumConstantValue(in_animationState)); |
| 695 | return castState<AnimationStateSet>(); |
| 696 | } |
| 697 | |
| 698 | Ref<TrackingUpdate> release() |
| 699 | { |
| 700 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 701 | COMPILE_ASSERT(sizeof(TrackingUpdate) == sizeof(JSON::Object), cannot_cast); |
| 702 | |
| 703 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 704 | auto result = WTFMove(*reinterpret_cast<Ref<TrackingUpdate>*>(&jsonResult)); |
| 705 | return result; |
| 706 | } |
| 707 | }; |
| 708 | |
| 709 | /* |
| 710 | * Synthetic constructor: |
| 711 | * Ref<TrackingUpdate> result = TrackingUpdate::create() |
| 712 | * .setTrackingAnimationId(...) |
| 713 | * .setAnimationState(...) |
| 714 | * .release(); |
| 715 | */ |
| 716 | static Builder<NoFieldsSet> create() |
| 717 | { |
| 718 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 719 | } |
| 720 | |
| 721 | void setNodeId(int in_opt_nodeId) |
| 722 | { |
| 723 | JSON::ObjectBase::setInteger("nodeId"_s , in_opt_nodeId); |
| 724 | } |
| 725 | |
| 726 | void setAnimationName(const String& in_opt_animationName) |
| 727 | { |
| 728 | JSON::ObjectBase::setString("animationName"_s , in_opt_animationName); |
| 729 | } |
| 730 | |
| 731 | void setTransitionProperty(const String& in_opt_transitionProperty) |
| 732 | { |
| 733 | JSON::ObjectBase::setString("transitionProperty"_s , in_opt_transitionProperty); |
| 734 | } |
| 735 | }; |
| 736 | |
| 737 | } // Animation |
| 738 | |
| 739 | namespace ApplicationCache { |
| 740 | |
| 741 | /* Detailed application cache resource information. */ |
| 742 | class ApplicationCacheResource final : public JSON::ObjectBase { |
| 743 | public: |
| 744 | enum { |
| 745 | NoFieldsSet = 0, |
| 746 | UrlSet = 1 << 0, |
| 747 | SizeSet = 1 << 1, |
| 748 | TypeSet = 1 << 2, |
| 749 | AllFieldsSet = (UrlSet | SizeSet | TypeSet) |
| 750 | }; |
| 751 | |
| 752 | template<int STATE> |
| 753 | class Builder { |
| 754 | private: |
| 755 | RefPtr<JSON::Object> m_result; |
| 756 | |
| 757 | template<int STEP> Builder<STATE | STEP>& castState() |
| 758 | { |
| 759 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 760 | } |
| 761 | |
| 762 | Builder(Ref</*ApplicationCacheResource*/JSON::Object>&& object) |
| 763 | : m_result(WTFMove(object)) |
| 764 | { |
| 765 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 766 | } |
| 767 | friend class ApplicationCacheResource; |
| 768 | public: |
| 769 | |
| 770 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 771 | { |
| 772 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 773 | m_result->setString("url"_s , in_url); |
| 774 | return castState<UrlSet>(); |
| 775 | } |
| 776 | |
| 777 | Builder<STATE | SizeSet>& setSize(int in_size) |
| 778 | { |
| 779 | COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set); |
| 780 | m_result->setInteger("size"_s , in_size); |
| 781 | return castState<SizeSet>(); |
| 782 | } |
| 783 | |
| 784 | Builder<STATE | TypeSet>& setType(const String& in_type) |
| 785 | { |
| 786 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 787 | m_result->setString("type"_s , in_type); |
| 788 | return castState<TypeSet>(); |
| 789 | } |
| 790 | |
| 791 | Ref<ApplicationCacheResource> release() |
| 792 | { |
| 793 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 794 | COMPILE_ASSERT(sizeof(ApplicationCacheResource) == sizeof(JSON::Object), cannot_cast); |
| 795 | |
| 796 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 797 | auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCacheResource>*>(&jsonResult)); |
| 798 | return result; |
| 799 | } |
| 800 | }; |
| 801 | |
| 802 | /* |
| 803 | * Synthetic constructor: |
| 804 | * Ref<ApplicationCacheResource> result = ApplicationCacheResource::create() |
| 805 | * .setUrl(...) |
| 806 | * .setSize(...) |
| 807 | * .setType(...) |
| 808 | * .release(); |
| 809 | */ |
| 810 | static Builder<NoFieldsSet> create() |
| 811 | { |
| 812 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 813 | } |
| 814 | }; |
| 815 | |
| 816 | /* Detailed application cache information. */ |
| 817 | class ApplicationCache final : public JSON::ObjectBase { |
| 818 | public: |
| 819 | enum { |
| 820 | NoFieldsSet = 0, |
| 821 | ManifestURLSet = 1 << 0, |
| 822 | SizeSet = 1 << 1, |
| 823 | CreationTimeSet = 1 << 2, |
| 824 | UpdateTimeSet = 1 << 3, |
| 825 | ResourcesSet = 1 << 4, |
| 826 | AllFieldsSet = (ManifestURLSet | SizeSet | CreationTimeSet | UpdateTimeSet | ResourcesSet) |
| 827 | }; |
| 828 | |
| 829 | template<int STATE> |
| 830 | class Builder { |
| 831 | private: |
| 832 | RefPtr<JSON::Object> m_result; |
| 833 | |
| 834 | template<int STEP> Builder<STATE | STEP>& castState() |
| 835 | { |
| 836 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 837 | } |
| 838 | |
| 839 | Builder(Ref</*ApplicationCache*/JSON::Object>&& object) |
| 840 | : m_result(WTFMove(object)) |
| 841 | { |
| 842 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 843 | } |
| 844 | friend class ApplicationCache; |
| 845 | public: |
| 846 | |
| 847 | Builder<STATE | ManifestURLSet>& setManifestURL(const String& in_manifestURL) |
| 848 | { |
| 849 | COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set); |
| 850 | m_result->setString("manifestURL"_s , in_manifestURL); |
| 851 | return castState<ManifestURLSet>(); |
| 852 | } |
| 853 | |
| 854 | Builder<STATE | SizeSet>& setSize(double in_size) |
| 855 | { |
| 856 | COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set); |
| 857 | m_result->setDouble("size"_s , in_size); |
| 858 | return castState<SizeSet>(); |
| 859 | } |
| 860 | |
| 861 | Builder<STATE | CreationTimeSet>& setCreationTime(double in_creationTime) |
| 862 | { |
| 863 | COMPILE_ASSERT(!(STATE & CreationTimeSet), property_creationTime_already_set); |
| 864 | m_result->setDouble("creationTime"_s , in_creationTime); |
| 865 | return castState<CreationTimeSet>(); |
| 866 | } |
| 867 | |
| 868 | Builder<STATE | UpdateTimeSet>& setUpdateTime(double in_updateTime) |
| 869 | { |
| 870 | COMPILE_ASSERT(!(STATE & UpdateTimeSet), property_updateTime_already_set); |
| 871 | m_result->setDouble("updateTime"_s , in_updateTime); |
| 872 | return castState<UpdateTimeSet>(); |
| 873 | } |
| 874 | |
| 875 | Builder<STATE | ResourcesSet>& setResources(Ref<JSON::ArrayOf<Protocol::ApplicationCache::ApplicationCacheResource>>&& in_resources) |
| 876 | { |
| 877 | COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set); |
| 878 | m_result->setArray("resources"_s , WTFMove(in_resources)); |
| 879 | return castState<ResourcesSet>(); |
| 880 | } |
| 881 | |
| 882 | Ref<ApplicationCache> release() |
| 883 | { |
| 884 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 885 | COMPILE_ASSERT(sizeof(ApplicationCache) == sizeof(JSON::Object), cannot_cast); |
| 886 | |
| 887 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 888 | auto result = WTFMove(*reinterpret_cast<Ref<ApplicationCache>*>(&jsonResult)); |
| 889 | return result; |
| 890 | } |
| 891 | }; |
| 892 | |
| 893 | /* |
| 894 | * Synthetic constructor: |
| 895 | * Ref<ApplicationCache> result = ApplicationCache::create() |
| 896 | * .setManifestURL(...) |
| 897 | * .setSize(...) |
| 898 | * .setCreationTime(...) |
| 899 | * .setUpdateTime(...) |
| 900 | * .setResources(...) |
| 901 | * .release(); |
| 902 | */ |
| 903 | static Builder<NoFieldsSet> create() |
| 904 | { |
| 905 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 906 | } |
| 907 | }; |
| 908 | |
| 909 | /* Frame identifier - manifest URL pair. */ |
| 910 | class FrameWithManifest final : public JSON::ObjectBase { |
| 911 | public: |
| 912 | enum { |
| 913 | NoFieldsSet = 0, |
| 914 | FrameIdSet = 1 << 0, |
| 915 | ManifestURLSet = 1 << 1, |
| 916 | StatusSet = 1 << 2, |
| 917 | AllFieldsSet = (FrameIdSet | ManifestURLSet | StatusSet) |
| 918 | }; |
| 919 | |
| 920 | template<int STATE> |
| 921 | class Builder { |
| 922 | private: |
| 923 | RefPtr<JSON::Object> m_result; |
| 924 | |
| 925 | template<int STEP> Builder<STATE | STEP>& castState() |
| 926 | { |
| 927 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 928 | } |
| 929 | |
| 930 | Builder(Ref</*FrameWithManifest*/JSON::Object>&& object) |
| 931 | : m_result(WTFMove(object)) |
| 932 | { |
| 933 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 934 | } |
| 935 | friend class FrameWithManifest; |
| 936 | public: |
| 937 | |
| 938 | Builder<STATE | FrameIdSet>& setFrameId(const String& in_frameId) |
| 939 | { |
| 940 | COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set); |
| 941 | m_result->setString("frameId"_s , in_frameId); |
| 942 | return castState<FrameIdSet>(); |
| 943 | } |
| 944 | |
| 945 | Builder<STATE | ManifestURLSet>& setManifestURL(const String& in_manifestURL) |
| 946 | { |
| 947 | COMPILE_ASSERT(!(STATE & ManifestURLSet), property_manifestURL_already_set); |
| 948 | m_result->setString("manifestURL"_s , in_manifestURL); |
| 949 | return castState<ManifestURLSet>(); |
| 950 | } |
| 951 | |
| 952 | Builder<STATE | StatusSet>& setStatus(int in_status) |
| 953 | { |
| 954 | COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set); |
| 955 | m_result->setInteger("status"_s , in_status); |
| 956 | return castState<StatusSet>(); |
| 957 | } |
| 958 | |
| 959 | Ref<FrameWithManifest> release() |
| 960 | { |
| 961 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 962 | COMPILE_ASSERT(sizeof(FrameWithManifest) == sizeof(JSON::Object), cannot_cast); |
| 963 | |
| 964 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 965 | auto result = WTFMove(*reinterpret_cast<Ref<FrameWithManifest>*>(&jsonResult)); |
| 966 | return result; |
| 967 | } |
| 968 | }; |
| 969 | |
| 970 | /* |
| 971 | * Synthetic constructor: |
| 972 | * Ref<FrameWithManifest> result = FrameWithManifest::create() |
| 973 | * .setFrameId(...) |
| 974 | * .setManifestURL(...) |
| 975 | * .setStatus(...) |
| 976 | * .release(); |
| 977 | */ |
| 978 | static Builder<NoFieldsSet> create() |
| 979 | { |
| 980 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 981 | } |
| 982 | }; |
| 983 | |
| 984 | } // ApplicationCache |
| 985 | |
| 986 | namespace Browser { |
| 987 | |
| 988 | /* Information about an extension. */ |
| 989 | class Extension final : public JSON::ObjectBase { |
| 990 | public: |
| 991 | enum { |
| 992 | NoFieldsSet = 0, |
| 993 | ExtensionIdSet = 1 << 0, |
| 994 | NameSet = 1 << 1, |
| 995 | AllFieldsSet = (ExtensionIdSet | NameSet) |
| 996 | }; |
| 997 | |
| 998 | template<int STATE> |
| 999 | class Builder { |
| 1000 | private: |
| 1001 | RefPtr<JSON::Object> m_result; |
| 1002 | |
| 1003 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1004 | { |
| 1005 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1006 | } |
| 1007 | |
| 1008 | Builder(Ref</*Extension*/JSON::Object>&& object) |
| 1009 | : m_result(WTFMove(object)) |
| 1010 | { |
| 1011 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1012 | } |
| 1013 | friend class Extension; |
| 1014 | public: |
| 1015 | |
| 1016 | Builder<STATE | ExtensionIdSet>& setExtensionId(const String& in_extensionId) |
| 1017 | { |
| 1018 | COMPILE_ASSERT(!(STATE & ExtensionIdSet), property_extensionId_already_set); |
| 1019 | m_result->setString("extensionId"_s , in_extensionId); |
| 1020 | return castState<ExtensionIdSet>(); |
| 1021 | } |
| 1022 | |
| 1023 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 1024 | { |
| 1025 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 1026 | m_result->setString("name"_s , in_name); |
| 1027 | return castState<NameSet>(); |
| 1028 | } |
| 1029 | |
| 1030 | Ref<Extension> release() |
| 1031 | { |
| 1032 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1033 | COMPILE_ASSERT(sizeof(Extension) == sizeof(JSON::Object), cannot_cast); |
| 1034 | |
| 1035 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1036 | auto result = WTFMove(*reinterpret_cast<Ref<Extension>*>(&jsonResult)); |
| 1037 | return result; |
| 1038 | } |
| 1039 | }; |
| 1040 | |
| 1041 | /* |
| 1042 | * Synthetic constructor: |
| 1043 | * Ref<Extension> result = Extension::create() |
| 1044 | * .setExtensionId(...) |
| 1045 | * .setName(...) |
| 1046 | * .release(); |
| 1047 | */ |
| 1048 | static Builder<NoFieldsSet> create() |
| 1049 | { |
| 1050 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1051 | } |
| 1052 | }; |
| 1053 | |
| 1054 | } // Browser |
| 1055 | |
| 1056 | #if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 1057 | namespace CPUProfiler { |
| 1058 | |
| 1059 | /* CPU usage for an individual thread. */ |
| 1060 | class ThreadInfo final : public JSON::ObjectBase { |
| 1061 | public: |
| 1062 | // Named after property name 'type' while generating ThreadInfo. |
| 1063 | enum class Type { |
| 1064 | Main = 14, |
| 1065 | WebKit = 15, |
| 1066 | }; // enum class Type |
| 1067 | |
| 1068 | enum { |
| 1069 | NoFieldsSet = 0, |
| 1070 | NameSet = 1 << 0, |
| 1071 | UsageSet = 1 << 1, |
| 1072 | AllFieldsSet = (NameSet | UsageSet) |
| 1073 | }; |
| 1074 | |
| 1075 | template<int STATE> |
| 1076 | class Builder { |
| 1077 | private: |
| 1078 | RefPtr<JSON::Object> m_result; |
| 1079 | |
| 1080 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1081 | { |
| 1082 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1083 | } |
| 1084 | |
| 1085 | Builder(Ref</*ThreadInfo*/JSON::Object>&& object) |
| 1086 | : m_result(WTFMove(object)) |
| 1087 | { |
| 1088 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1089 | } |
| 1090 | friend class ThreadInfo; |
| 1091 | public: |
| 1092 | |
| 1093 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 1094 | { |
| 1095 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 1096 | m_result->setString("name"_s , in_name); |
| 1097 | return castState<NameSet>(); |
| 1098 | } |
| 1099 | |
| 1100 | Builder<STATE | UsageSet>& setUsage(double in_usage) |
| 1101 | { |
| 1102 | COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set); |
| 1103 | m_result->setDouble("usage"_s , in_usage); |
| 1104 | return castState<UsageSet>(); |
| 1105 | } |
| 1106 | |
| 1107 | Ref<ThreadInfo> release() |
| 1108 | { |
| 1109 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1110 | COMPILE_ASSERT(sizeof(ThreadInfo) == sizeof(JSON::Object), cannot_cast); |
| 1111 | |
| 1112 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1113 | auto result = WTFMove(*reinterpret_cast<Ref<ThreadInfo>*>(&jsonResult)); |
| 1114 | return result; |
| 1115 | } |
| 1116 | }; |
| 1117 | |
| 1118 | /* |
| 1119 | * Synthetic constructor: |
| 1120 | * Ref<ThreadInfo> result = ThreadInfo::create() |
| 1121 | * .setName(...) |
| 1122 | * .setUsage(...) |
| 1123 | * .release(); |
| 1124 | */ |
| 1125 | static Builder<NoFieldsSet> create() |
| 1126 | { |
| 1127 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1128 | } |
| 1129 | |
| 1130 | void setType(Type in_opt_type) |
| 1131 | { |
| 1132 | JSON::ObjectBase::setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_opt_type)); |
| 1133 | } |
| 1134 | |
| 1135 | void setTargetId(const String& in_opt_targetId) |
| 1136 | { |
| 1137 | JSON::ObjectBase::setString("targetId"_s , in_opt_targetId); |
| 1138 | } |
| 1139 | }; |
| 1140 | |
| 1141 | class Event final : public JSON::ObjectBase { |
| 1142 | public: |
| 1143 | enum { |
| 1144 | NoFieldsSet = 0, |
| 1145 | TimestampSet = 1 << 0, |
| 1146 | UsageSet = 1 << 1, |
| 1147 | AllFieldsSet = (TimestampSet | UsageSet) |
| 1148 | }; |
| 1149 | |
| 1150 | template<int STATE> |
| 1151 | class Builder { |
| 1152 | private: |
| 1153 | RefPtr<JSON::Object> m_result; |
| 1154 | |
| 1155 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1156 | { |
| 1157 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1158 | } |
| 1159 | |
| 1160 | Builder(Ref</*Event*/JSON::Object>&& object) |
| 1161 | : m_result(WTFMove(object)) |
| 1162 | { |
| 1163 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1164 | } |
| 1165 | friend class Event; |
| 1166 | public: |
| 1167 | |
| 1168 | Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp) |
| 1169 | { |
| 1170 | COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set); |
| 1171 | m_result->setDouble("timestamp"_s , in_timestamp); |
| 1172 | return castState<TimestampSet>(); |
| 1173 | } |
| 1174 | |
| 1175 | Builder<STATE | UsageSet>& setUsage(double in_usage) |
| 1176 | { |
| 1177 | COMPILE_ASSERT(!(STATE & UsageSet), property_usage_already_set); |
| 1178 | m_result->setDouble("usage"_s , in_usage); |
| 1179 | return castState<UsageSet>(); |
| 1180 | } |
| 1181 | |
| 1182 | Ref<Event> release() |
| 1183 | { |
| 1184 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1185 | COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast); |
| 1186 | |
| 1187 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1188 | auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult)); |
| 1189 | return result; |
| 1190 | } |
| 1191 | }; |
| 1192 | |
| 1193 | /* |
| 1194 | * Synthetic constructor: |
| 1195 | * Ref<Event> result = Event::create() |
| 1196 | * .setTimestamp(...) |
| 1197 | * .setUsage(...) |
| 1198 | * .release(); |
| 1199 | */ |
| 1200 | static Builder<NoFieldsSet> create() |
| 1201 | { |
| 1202 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1203 | } |
| 1204 | |
| 1205 | void setThreads(Ref<JSON::ArrayOf<Protocol::CPUProfiler::ThreadInfo>>&& in_opt_threads) |
| 1206 | { |
| 1207 | JSON::ObjectBase::setArray("threads"_s , WTFMove(in_opt_threads)); |
| 1208 | } |
| 1209 | }; |
| 1210 | |
| 1211 | } // CPUProfiler |
| 1212 | #endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 1213 | |
| 1214 | namespace CSS { |
| 1215 | |
| 1216 | /* This object identifies a CSS style in a unique way. */ |
| 1217 | class CSSStyleId final : public JSON::ObjectBase { |
| 1218 | public: |
| 1219 | enum { |
| 1220 | NoFieldsSet = 0, |
| 1221 | StyleSheetIdSet = 1 << 0, |
| 1222 | OrdinalSet = 1 << 1, |
| 1223 | AllFieldsSet = (StyleSheetIdSet | OrdinalSet) |
| 1224 | }; |
| 1225 | |
| 1226 | template<int STATE> |
| 1227 | class Builder { |
| 1228 | private: |
| 1229 | RefPtr<JSON::Object> m_result; |
| 1230 | |
| 1231 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1232 | { |
| 1233 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1234 | } |
| 1235 | |
| 1236 | Builder(Ref</*CSSStyleId*/JSON::Object>&& object) |
| 1237 | : m_result(WTFMove(object)) |
| 1238 | { |
| 1239 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1240 | } |
| 1241 | friend class CSSStyleId; |
| 1242 | public: |
| 1243 | |
| 1244 | Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId) |
| 1245 | { |
| 1246 | COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set); |
| 1247 | m_result->setString("styleSheetId"_s , in_styleSheetId); |
| 1248 | return castState<StyleSheetIdSet>(); |
| 1249 | } |
| 1250 | |
| 1251 | Builder<STATE | OrdinalSet>& setOrdinal(int in_ordinal) |
| 1252 | { |
| 1253 | COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set); |
| 1254 | m_result->setInteger("ordinal"_s , in_ordinal); |
| 1255 | return castState<OrdinalSet>(); |
| 1256 | } |
| 1257 | |
| 1258 | Ref<CSSStyleId> release() |
| 1259 | { |
| 1260 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1261 | COMPILE_ASSERT(sizeof(CSSStyleId) == sizeof(JSON::Object), cannot_cast); |
| 1262 | |
| 1263 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1264 | auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleId>*>(&jsonResult)); |
| 1265 | return result; |
| 1266 | } |
| 1267 | }; |
| 1268 | |
| 1269 | /* |
| 1270 | * Synthetic constructor: |
| 1271 | * Ref<CSSStyleId> result = CSSStyleId::create() |
| 1272 | * .setStyleSheetId(...) |
| 1273 | * .setOrdinal(...) |
| 1274 | * .release(); |
| 1275 | */ |
| 1276 | static Builder<NoFieldsSet> create() |
| 1277 | { |
| 1278 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1279 | } |
| 1280 | }; |
| 1281 | |
| 1282 | /* Stylesheet type: "user" for user stylesheets, "user-agent" for user-agent stylesheets, "inspector" for stylesheets created by the inspector (i.e. those holding the "via inspector" rules), "regular" for regular stylesheets. */ |
| 1283 | enum class StyleSheetOrigin { |
| 1284 | User = 16, |
| 1285 | UserAgent = 17, |
| 1286 | Author = 18, |
| 1287 | Inspector = 19, |
| 1288 | }; // enum class StyleSheetOrigin |
| 1289 | |
| 1290 | /* This object identifies a CSS rule in a unique way. */ |
| 1291 | class CSSRuleId final : public JSON::ObjectBase { |
| 1292 | public: |
| 1293 | enum { |
| 1294 | NoFieldsSet = 0, |
| 1295 | StyleSheetIdSet = 1 << 0, |
| 1296 | OrdinalSet = 1 << 1, |
| 1297 | AllFieldsSet = (StyleSheetIdSet | OrdinalSet) |
| 1298 | }; |
| 1299 | |
| 1300 | template<int STATE> |
| 1301 | class Builder { |
| 1302 | private: |
| 1303 | RefPtr<JSON::Object> m_result; |
| 1304 | |
| 1305 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1306 | { |
| 1307 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1308 | } |
| 1309 | |
| 1310 | Builder(Ref</*CSSRuleId*/JSON::Object>&& object) |
| 1311 | : m_result(WTFMove(object)) |
| 1312 | { |
| 1313 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1314 | } |
| 1315 | friend class CSSRuleId; |
| 1316 | public: |
| 1317 | |
| 1318 | Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId) |
| 1319 | { |
| 1320 | COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set); |
| 1321 | m_result->setString("styleSheetId"_s , in_styleSheetId); |
| 1322 | return castState<StyleSheetIdSet>(); |
| 1323 | } |
| 1324 | |
| 1325 | Builder<STATE | OrdinalSet>& setOrdinal(int in_ordinal) |
| 1326 | { |
| 1327 | COMPILE_ASSERT(!(STATE & OrdinalSet), property_ordinal_already_set); |
| 1328 | m_result->setInteger("ordinal"_s , in_ordinal); |
| 1329 | return castState<OrdinalSet>(); |
| 1330 | } |
| 1331 | |
| 1332 | Ref<CSSRuleId> release() |
| 1333 | { |
| 1334 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1335 | COMPILE_ASSERT(sizeof(CSSRuleId) == sizeof(JSON::Object), cannot_cast); |
| 1336 | |
| 1337 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1338 | auto result = WTFMove(*reinterpret_cast<Ref<CSSRuleId>*>(&jsonResult)); |
| 1339 | return result; |
| 1340 | } |
| 1341 | }; |
| 1342 | |
| 1343 | /* |
| 1344 | * Synthetic constructor: |
| 1345 | * Ref<CSSRuleId> result = CSSRuleId::create() |
| 1346 | * .setStyleSheetId(...) |
| 1347 | * .setOrdinal(...) |
| 1348 | * .release(); |
| 1349 | */ |
| 1350 | static Builder<NoFieldsSet> create() |
| 1351 | { |
| 1352 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1353 | } |
| 1354 | }; |
| 1355 | |
| 1356 | /* Pseudo-style identifier (see <code>enum PseudoId</code> in <code>RenderStyleConstants.h</code>). */ |
| 1357 | enum class PseudoId { |
| 1358 | FirstLine = 20, |
| 1359 | FirstLetter = 21, |
| 1360 | Highlight = 22, |
| 1361 | Marker = 23, |
| 1362 | Before = 24, |
| 1363 | After = 25, |
| 1364 | Selection = 26, |
| 1365 | Scrollbar = 27, |
| 1366 | ScrollbarThumb = 28, |
| 1367 | ScrollbarButton = 29, |
| 1368 | ScrollbarTrack = 30, |
| 1369 | ScrollbarTrackPiece = 31, |
| 1370 | ScrollbarCorner = 32, |
| 1371 | Resizer = 33, |
| 1372 | }; // enum class PseudoId |
| 1373 | |
| 1374 | /* CSS rule collection for a single pseudo style. */ |
| 1375 | class PseudoIdMatches final : public JSON::ObjectBase { |
| 1376 | public: |
| 1377 | enum { |
| 1378 | NoFieldsSet = 0, |
| 1379 | PseudoIdSet = 1 << 0, |
| 1380 | MatchesSet = 1 << 1, |
| 1381 | AllFieldsSet = (PseudoIdSet | MatchesSet) |
| 1382 | }; |
| 1383 | |
| 1384 | template<int STATE> |
| 1385 | class Builder { |
| 1386 | private: |
| 1387 | RefPtr<JSON::Object> m_result; |
| 1388 | |
| 1389 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1390 | { |
| 1391 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1392 | } |
| 1393 | |
| 1394 | Builder(Ref</*PseudoIdMatches*/JSON::Object>&& object) |
| 1395 | : m_result(WTFMove(object)) |
| 1396 | { |
| 1397 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1398 | } |
| 1399 | friend class PseudoIdMatches; |
| 1400 | public: |
| 1401 | |
| 1402 | Builder<STATE | PseudoIdSet>& setPseudoId(Protocol::CSS::PseudoId in_pseudoId) |
| 1403 | { |
| 1404 | COMPILE_ASSERT(!(STATE & PseudoIdSet), property_pseudoId_already_set); |
| 1405 | m_result->setString("pseudoId"_s , Protocol::Helpers::getEnumConstantValue(in_pseudoId)); |
| 1406 | return castState<PseudoIdSet>(); |
| 1407 | } |
| 1408 | |
| 1409 | Builder<STATE | MatchesSet>& setMatches(Ref<JSON::ArrayOf<Protocol::CSS::RuleMatch>>&& in_matches) |
| 1410 | { |
| 1411 | COMPILE_ASSERT(!(STATE & MatchesSet), property_matches_already_set); |
| 1412 | m_result->setArray("matches"_s , WTFMove(in_matches)); |
| 1413 | return castState<MatchesSet>(); |
| 1414 | } |
| 1415 | |
| 1416 | Ref<PseudoIdMatches> release() |
| 1417 | { |
| 1418 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1419 | COMPILE_ASSERT(sizeof(PseudoIdMatches) == sizeof(JSON::Object), cannot_cast); |
| 1420 | |
| 1421 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1422 | auto result = WTFMove(*reinterpret_cast<Ref<PseudoIdMatches>*>(&jsonResult)); |
| 1423 | return result; |
| 1424 | } |
| 1425 | }; |
| 1426 | |
| 1427 | /* |
| 1428 | * Synthetic constructor: |
| 1429 | * Ref<PseudoIdMatches> result = PseudoIdMatches::create() |
| 1430 | * .setPseudoId(...) |
| 1431 | * .setMatches(...) |
| 1432 | * .release(); |
| 1433 | */ |
| 1434 | static Builder<NoFieldsSet> create() |
| 1435 | { |
| 1436 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1437 | } |
| 1438 | }; |
| 1439 | |
| 1440 | /* CSS rule collection for a single pseudo style. */ |
| 1441 | class InheritedStyleEntry final : public JSON::ObjectBase { |
| 1442 | public: |
| 1443 | enum { |
| 1444 | NoFieldsSet = 0, |
| 1445 | MatchedCSSRulesSet = 1 << 0, |
| 1446 | AllFieldsSet = (MatchedCSSRulesSet) |
| 1447 | }; |
| 1448 | |
| 1449 | template<int STATE> |
| 1450 | class Builder { |
| 1451 | private: |
| 1452 | RefPtr<JSON::Object> m_result; |
| 1453 | |
| 1454 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1455 | { |
| 1456 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1457 | } |
| 1458 | |
| 1459 | Builder(Ref</*InheritedStyleEntry*/JSON::Object>&& object) |
| 1460 | : m_result(WTFMove(object)) |
| 1461 | { |
| 1462 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1463 | } |
| 1464 | friend class InheritedStyleEntry; |
| 1465 | public: |
| 1466 | |
| 1467 | Builder<STATE | MatchedCSSRulesSet>& setMatchedCSSRules(Ref<JSON::ArrayOf<Protocol::CSS::RuleMatch>>&& in_matchedCSSRules) |
| 1468 | { |
| 1469 | COMPILE_ASSERT(!(STATE & MatchedCSSRulesSet), property_matchedCSSRules_already_set); |
| 1470 | m_result->setArray("matchedCSSRules"_s , WTFMove(in_matchedCSSRules)); |
| 1471 | return castState<MatchedCSSRulesSet>(); |
| 1472 | } |
| 1473 | |
| 1474 | Ref<InheritedStyleEntry> release() |
| 1475 | { |
| 1476 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1477 | COMPILE_ASSERT(sizeof(InheritedStyleEntry) == sizeof(JSON::Object), cannot_cast); |
| 1478 | |
| 1479 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1480 | auto result = WTFMove(*reinterpret_cast<Ref<InheritedStyleEntry>*>(&jsonResult)); |
| 1481 | return result; |
| 1482 | } |
| 1483 | }; |
| 1484 | |
| 1485 | /* |
| 1486 | * Synthetic constructor: |
| 1487 | * Ref<InheritedStyleEntry> result = InheritedStyleEntry::create() |
| 1488 | * .setMatchedCSSRules(...) |
| 1489 | * .release(); |
| 1490 | */ |
| 1491 | static Builder<NoFieldsSet> create() |
| 1492 | { |
| 1493 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1494 | } |
| 1495 | |
| 1496 | void setInlineStyle(Ref<Protocol::CSS::CSSStyle>&& in_opt_inlineStyle) |
| 1497 | { |
| 1498 | JSON::ObjectBase::setObject("inlineStyle"_s , WTFMove(in_opt_inlineStyle)); |
| 1499 | } |
| 1500 | }; |
| 1501 | |
| 1502 | /* Match data for a CSS rule. */ |
| 1503 | class RuleMatch final : public JSON::ObjectBase { |
| 1504 | public: |
| 1505 | enum { |
| 1506 | NoFieldsSet = 0, |
| 1507 | RuleSet = 1 << 0, |
| 1508 | = 1 << 1, |
| 1509 | AllFieldsSet = (RuleSet | MatchingSelectorsSet) |
| 1510 | }; |
| 1511 | |
| 1512 | template<int STATE> |
| 1513 | class Builder { |
| 1514 | private: |
| 1515 | RefPtr<JSON::Object> m_result; |
| 1516 | |
| 1517 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1518 | { |
| 1519 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1520 | } |
| 1521 | |
| 1522 | Builder(Ref</*RuleMatch*/JSON::Object>&& object) |
| 1523 | : m_result(WTFMove(object)) |
| 1524 | { |
| 1525 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1526 | } |
| 1527 | friend class RuleMatch; |
| 1528 | public: |
| 1529 | |
| 1530 | Builder<STATE | RuleSet>& setRule(Ref<Protocol::CSS::CSSRule>&& in_rule) |
| 1531 | { |
| 1532 | COMPILE_ASSERT(!(STATE & RuleSet), property_rule_already_set); |
| 1533 | m_result->setObject("rule"_s , WTFMove(in_rule)); |
| 1534 | return castState<RuleSet>(); |
| 1535 | } |
| 1536 | |
| 1537 | Builder<STATE | MatchingSelectorsSet>& setMatchingSelectors(Ref<JSON::ArrayOf<int>>&& in_matchingSelectors) |
| 1538 | { |
| 1539 | COMPILE_ASSERT(!(STATE & MatchingSelectorsSet), property_matchingSelectors_already_set); |
| 1540 | m_result->setArray("matchingSelectors"_s , WTFMove(in_matchingSelectors)); |
| 1541 | return castState<MatchingSelectorsSet>(); |
| 1542 | } |
| 1543 | |
| 1544 | Ref<RuleMatch> release() |
| 1545 | { |
| 1546 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1547 | COMPILE_ASSERT(sizeof(RuleMatch) == sizeof(JSON::Object), cannot_cast); |
| 1548 | |
| 1549 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1550 | auto result = WTFMove(*reinterpret_cast<Ref<RuleMatch>*>(&jsonResult)); |
| 1551 | return result; |
| 1552 | } |
| 1553 | }; |
| 1554 | |
| 1555 | /* |
| 1556 | * Synthetic constructor: |
| 1557 | * Ref<RuleMatch> result = RuleMatch::create() |
| 1558 | * .setRule(...) |
| 1559 | * .setMatchingSelectors(...) |
| 1560 | * .release(); |
| 1561 | */ |
| 1562 | static Builder<NoFieldsSet> create() |
| 1563 | { |
| 1564 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1565 | } |
| 1566 | }; |
| 1567 | |
| 1568 | /* CSS selector. */ |
| 1569 | class CSSSelector final : public JSON::ObjectBase { |
| 1570 | public: |
| 1571 | enum { |
| 1572 | NoFieldsSet = 0, |
| 1573 | TextSet = 1 << 0, |
| 1574 | AllFieldsSet = (TextSet) |
| 1575 | }; |
| 1576 | |
| 1577 | template<int STATE> |
| 1578 | class Builder { |
| 1579 | private: |
| 1580 | RefPtr<JSON::Object> m_result; |
| 1581 | |
| 1582 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1583 | { |
| 1584 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1585 | } |
| 1586 | |
| 1587 | Builder(Ref</*CSSSelector*/JSON::Object>&& object) |
| 1588 | : m_result(WTFMove(object)) |
| 1589 | { |
| 1590 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1591 | } |
| 1592 | friend class CSSSelector; |
| 1593 | public: |
| 1594 | |
| 1595 | Builder<STATE | TextSet>& setText(const String& in_text) |
| 1596 | { |
| 1597 | COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set); |
| 1598 | m_result->setString("text"_s , in_text); |
| 1599 | return castState<TextSet>(); |
| 1600 | } |
| 1601 | |
| 1602 | Ref<CSSSelector> release() |
| 1603 | { |
| 1604 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1605 | COMPILE_ASSERT(sizeof(CSSSelector) == sizeof(JSON::Object), cannot_cast); |
| 1606 | |
| 1607 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1608 | auto result = WTFMove(*reinterpret_cast<Ref<CSSSelector>*>(&jsonResult)); |
| 1609 | return result; |
| 1610 | } |
| 1611 | }; |
| 1612 | |
| 1613 | /* |
| 1614 | * Synthetic constructor: |
| 1615 | * Ref<CSSSelector> result = CSSSelector::create() |
| 1616 | * .setText(...) |
| 1617 | * .release(); |
| 1618 | */ |
| 1619 | static Builder<NoFieldsSet> create() |
| 1620 | { |
| 1621 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1622 | } |
| 1623 | |
| 1624 | void setSpecificity(Ref<JSON::ArrayOf<int>>&& in_opt_specificity) |
| 1625 | { |
| 1626 | JSON::ObjectBase::setArray("specificity"_s , WTFMove(in_opt_specificity)); |
| 1627 | } |
| 1628 | |
| 1629 | void setDynamic(bool in_opt_dynamic) |
| 1630 | { |
| 1631 | JSON::ObjectBase::setBoolean("dynamic"_s , in_opt_dynamic); |
| 1632 | } |
| 1633 | }; |
| 1634 | |
| 1635 | /* Selector list data. */ |
| 1636 | class SelectorList final : public JSON::ObjectBase { |
| 1637 | public: |
| 1638 | enum { |
| 1639 | NoFieldsSet = 0, |
| 1640 | = 1 << 0, |
| 1641 | TextSet = 1 << 1, |
| 1642 | AllFieldsSet = (SelectorsSet | TextSet) |
| 1643 | }; |
| 1644 | |
| 1645 | template<int STATE> |
| 1646 | class Builder { |
| 1647 | private: |
| 1648 | RefPtr<JSON::Object> m_result; |
| 1649 | |
| 1650 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1651 | { |
| 1652 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1653 | } |
| 1654 | |
| 1655 | Builder(Ref</*SelectorList*/JSON::Object>&& object) |
| 1656 | : m_result(WTFMove(object)) |
| 1657 | { |
| 1658 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1659 | } |
| 1660 | friend class SelectorList; |
| 1661 | public: |
| 1662 | |
| 1663 | Builder<STATE | SelectorsSet>& setSelectors(Ref<JSON::ArrayOf<Protocol::CSS::CSSSelector>>&& in_selectors) |
| 1664 | { |
| 1665 | COMPILE_ASSERT(!(STATE & SelectorsSet), property_selectors_already_set); |
| 1666 | m_result->setArray("selectors"_s , WTFMove(in_selectors)); |
| 1667 | return castState<SelectorsSet>(); |
| 1668 | } |
| 1669 | |
| 1670 | Builder<STATE | TextSet>& setText(const String& in_text) |
| 1671 | { |
| 1672 | COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set); |
| 1673 | m_result->setString("text"_s , in_text); |
| 1674 | return castState<TextSet>(); |
| 1675 | } |
| 1676 | |
| 1677 | Ref<SelectorList> release() |
| 1678 | { |
| 1679 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1680 | COMPILE_ASSERT(sizeof(SelectorList) == sizeof(JSON::Object), cannot_cast); |
| 1681 | |
| 1682 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1683 | auto result = WTFMove(*reinterpret_cast<Ref<SelectorList>*>(&jsonResult)); |
| 1684 | return result; |
| 1685 | } |
| 1686 | }; |
| 1687 | |
| 1688 | /* |
| 1689 | * Synthetic constructor: |
| 1690 | * Ref<SelectorList> result = SelectorList::create() |
| 1691 | * .setSelectors(...) |
| 1692 | * .setText(...) |
| 1693 | * .release(); |
| 1694 | */ |
| 1695 | static Builder<NoFieldsSet> create() |
| 1696 | { |
| 1697 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1698 | } |
| 1699 | |
| 1700 | void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range) |
| 1701 | { |
| 1702 | JSON::ObjectBase::setObject("range"_s , WTFMove(in_opt_range)); |
| 1703 | } |
| 1704 | }; |
| 1705 | |
| 1706 | /* CSS style information for a DOM style attribute. */ |
| 1707 | class CSSStyleAttribute final : public JSON::ObjectBase { |
| 1708 | public: |
| 1709 | enum { |
| 1710 | NoFieldsSet = 0, |
| 1711 | NameSet = 1 << 0, |
| 1712 | StyleSet = 1 << 1, |
| 1713 | AllFieldsSet = (NameSet | StyleSet) |
| 1714 | }; |
| 1715 | |
| 1716 | template<int STATE> |
| 1717 | class Builder { |
| 1718 | private: |
| 1719 | RefPtr<JSON::Object> m_result; |
| 1720 | |
| 1721 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1722 | { |
| 1723 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1724 | } |
| 1725 | |
| 1726 | Builder(Ref</*CSSStyleAttribute*/JSON::Object>&& object) |
| 1727 | : m_result(WTFMove(object)) |
| 1728 | { |
| 1729 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1730 | } |
| 1731 | friend class CSSStyleAttribute; |
| 1732 | public: |
| 1733 | |
| 1734 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 1735 | { |
| 1736 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 1737 | m_result->setString("name"_s , in_name); |
| 1738 | return castState<NameSet>(); |
| 1739 | } |
| 1740 | |
| 1741 | Builder<STATE | StyleSet>& setStyle(Ref<Protocol::CSS::CSSStyle>&& in_style) |
| 1742 | { |
| 1743 | COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set); |
| 1744 | m_result->setObject("style"_s , WTFMove(in_style)); |
| 1745 | return castState<StyleSet>(); |
| 1746 | } |
| 1747 | |
| 1748 | Ref<CSSStyleAttribute> release() |
| 1749 | { |
| 1750 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1751 | COMPILE_ASSERT(sizeof(CSSStyleAttribute) == sizeof(JSON::Object), cannot_cast); |
| 1752 | |
| 1753 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1754 | auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleAttribute>*>(&jsonResult)); |
| 1755 | return result; |
| 1756 | } |
| 1757 | }; |
| 1758 | |
| 1759 | /* |
| 1760 | * Synthetic constructor: |
| 1761 | * Ref<CSSStyleAttribute> result = CSSStyleAttribute::create() |
| 1762 | * .setName(...) |
| 1763 | * .setStyle(...) |
| 1764 | * .release(); |
| 1765 | */ |
| 1766 | static Builder<NoFieldsSet> create() |
| 1767 | { |
| 1768 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1769 | } |
| 1770 | }; |
| 1771 | |
| 1772 | /* CSS stylesheet meta-information. */ |
| 1773 | class final : public JSON::ObjectBase { |
| 1774 | public: |
| 1775 | enum { |
| 1776 | = 0, |
| 1777 | = 1 << 0, |
| 1778 | = 1 << 1, |
| 1779 | = 1 << 2, |
| 1780 | = 1 << 3, |
| 1781 | = 1 << 4, |
| 1782 | = 1 << 5, |
| 1783 | = 1 << 6, |
| 1784 | = 1 << 7, |
| 1785 | StartColumnSet = 1 << 8, |
| 1786 | = (StyleSheetIdSet | FrameIdSet | SourceURLSet | OriginSet | TitleSet | DisabledSet | IsInlineSet | StartLineSet | StartColumnSet) |
| 1787 | }; |
| 1788 | |
| 1789 | template<int STATE> |
| 1790 | class { |
| 1791 | private: |
| 1792 | RefPtr<JSON::Object> ; |
| 1793 | |
| 1794 | template<int STEP> Builder<STATE | STEP>& () |
| 1795 | { |
| 1796 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1797 | } |
| 1798 | |
| 1799 | (Ref</*CSSStyleSheetHeader*/JSON::Object>&& object) |
| 1800 | : m_result(WTFMove(object)) |
| 1801 | { |
| 1802 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1803 | } |
| 1804 | friend class CSSStyleSheetHeader; |
| 1805 | public: |
| 1806 | |
| 1807 | Builder<STATE | StyleSheetIdSet>& (const String& in_styleSheetId) |
| 1808 | { |
| 1809 | COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set); |
| 1810 | m_result->setString("styleSheetId"_s , in_styleSheetId); |
| 1811 | return castState<StyleSheetIdSet>(); |
| 1812 | } |
| 1813 | |
| 1814 | Builder<STATE | FrameIdSet>& (const String& in_frameId) |
| 1815 | { |
| 1816 | COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set); |
| 1817 | m_result->setString("frameId"_s , in_frameId); |
| 1818 | return castState<FrameIdSet>(); |
| 1819 | } |
| 1820 | |
| 1821 | Builder<STATE | SourceURLSet>& (const String& in_sourceURL) |
| 1822 | { |
| 1823 | COMPILE_ASSERT(!(STATE & SourceURLSet), property_sourceURL_already_set); |
| 1824 | m_result->setString("sourceURL"_s , in_sourceURL); |
| 1825 | return castState<SourceURLSet>(); |
| 1826 | } |
| 1827 | |
| 1828 | Builder<STATE | OriginSet>& (Protocol::CSS::StyleSheetOrigin in_origin) |
| 1829 | { |
| 1830 | COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set); |
| 1831 | m_result->setString("origin"_s , Protocol::Helpers::getEnumConstantValue(in_origin)); |
| 1832 | return castState<OriginSet>(); |
| 1833 | } |
| 1834 | |
| 1835 | Builder<STATE | TitleSet>& (const String& in_title) |
| 1836 | { |
| 1837 | COMPILE_ASSERT(!(STATE & TitleSet), property_title_already_set); |
| 1838 | m_result->setString("title"_s , in_title); |
| 1839 | return castState<TitleSet>(); |
| 1840 | } |
| 1841 | |
| 1842 | Builder<STATE | DisabledSet>& (bool in_disabled) |
| 1843 | { |
| 1844 | COMPILE_ASSERT(!(STATE & DisabledSet), property_disabled_already_set); |
| 1845 | m_result->setBoolean("disabled"_s , in_disabled); |
| 1846 | return castState<DisabledSet>(); |
| 1847 | } |
| 1848 | |
| 1849 | Builder<STATE | IsInlineSet>& (bool in_isInline) |
| 1850 | { |
| 1851 | COMPILE_ASSERT(!(STATE & IsInlineSet), property_isInline_already_set); |
| 1852 | m_result->setBoolean("isInline"_s , in_isInline); |
| 1853 | return castState<IsInlineSet>(); |
| 1854 | } |
| 1855 | |
| 1856 | Builder<STATE | StartLineSet>& (double in_startLine) |
| 1857 | { |
| 1858 | COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set); |
| 1859 | m_result->setDouble("startLine"_s , in_startLine); |
| 1860 | return castState<StartLineSet>(); |
| 1861 | } |
| 1862 | |
| 1863 | Builder<STATE | StartColumnSet>& setStartColumn(double in_startColumn) |
| 1864 | { |
| 1865 | COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set); |
| 1866 | m_result->setDouble("startColumn"_s , in_startColumn); |
| 1867 | return castState<StartColumnSet>(); |
| 1868 | } |
| 1869 | |
| 1870 | Ref<CSSStyleSheetHeader> () |
| 1871 | { |
| 1872 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1873 | COMPILE_ASSERT(sizeof(CSSStyleSheetHeader) == sizeof(JSON::Object), cannot_cast); |
| 1874 | |
| 1875 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1876 | auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetHeader>*>(&jsonResult)); |
| 1877 | return result; |
| 1878 | } |
| 1879 | }; |
| 1880 | |
| 1881 | /* |
| 1882 | * Synthetic constructor: |
| 1883 | * Ref<CSSStyleSheetHeader> result = CSSStyleSheetHeader::create() |
| 1884 | * .setStyleSheetId(...) |
| 1885 | * .setFrameId(...) |
| 1886 | * .setSourceURL(...) |
| 1887 | * .setOrigin(...) |
| 1888 | * .setTitle(...) |
| 1889 | * .setDisabled(...) |
| 1890 | * .setIsInline(...) |
| 1891 | * .setStartLine(...) |
| 1892 | * .setStartColumn(...) |
| 1893 | * .release(); |
| 1894 | */ |
| 1895 | static Builder<NoFieldsSet> () |
| 1896 | { |
| 1897 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1898 | } |
| 1899 | }; |
| 1900 | |
| 1901 | /* CSS stylesheet contents. */ |
| 1902 | class CSSStyleSheetBody final : public JSON::ObjectBase { |
| 1903 | public: |
| 1904 | enum { |
| 1905 | NoFieldsSet = 0, |
| 1906 | StyleSheetIdSet = 1 << 0, |
| 1907 | RulesSet = 1 << 1, |
| 1908 | AllFieldsSet = (StyleSheetIdSet | RulesSet) |
| 1909 | }; |
| 1910 | |
| 1911 | template<int STATE> |
| 1912 | class Builder { |
| 1913 | private: |
| 1914 | RefPtr<JSON::Object> m_result; |
| 1915 | |
| 1916 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1917 | { |
| 1918 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1919 | } |
| 1920 | |
| 1921 | Builder(Ref</*CSSStyleSheetBody*/JSON::Object>&& object) |
| 1922 | : m_result(WTFMove(object)) |
| 1923 | { |
| 1924 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1925 | } |
| 1926 | friend class CSSStyleSheetBody; |
| 1927 | public: |
| 1928 | |
| 1929 | Builder<STATE | StyleSheetIdSet>& setStyleSheetId(const String& in_styleSheetId) |
| 1930 | { |
| 1931 | COMPILE_ASSERT(!(STATE & StyleSheetIdSet), property_styleSheetId_already_set); |
| 1932 | m_result->setString("styleSheetId"_s , in_styleSheetId); |
| 1933 | return castState<StyleSheetIdSet>(); |
| 1934 | } |
| 1935 | |
| 1936 | Builder<STATE | RulesSet>& setRules(Ref<JSON::ArrayOf<Protocol::CSS::CSSRule>>&& in_rules) |
| 1937 | { |
| 1938 | COMPILE_ASSERT(!(STATE & RulesSet), property_rules_already_set); |
| 1939 | m_result->setArray("rules"_s , WTFMove(in_rules)); |
| 1940 | return castState<RulesSet>(); |
| 1941 | } |
| 1942 | |
| 1943 | Ref<CSSStyleSheetBody> release() |
| 1944 | { |
| 1945 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 1946 | COMPILE_ASSERT(sizeof(CSSStyleSheetBody) == sizeof(JSON::Object), cannot_cast); |
| 1947 | |
| 1948 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 1949 | auto result = WTFMove(*reinterpret_cast<Ref<CSSStyleSheetBody>*>(&jsonResult)); |
| 1950 | return result; |
| 1951 | } |
| 1952 | }; |
| 1953 | |
| 1954 | /* |
| 1955 | * Synthetic constructor: |
| 1956 | * Ref<CSSStyleSheetBody> result = CSSStyleSheetBody::create() |
| 1957 | * .setStyleSheetId(...) |
| 1958 | * .setRules(...) |
| 1959 | * .release(); |
| 1960 | */ |
| 1961 | static Builder<NoFieldsSet> create() |
| 1962 | { |
| 1963 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 1964 | } |
| 1965 | |
| 1966 | void setText(const String& in_opt_text) |
| 1967 | { |
| 1968 | JSON::ObjectBase::setString("text"_s , in_opt_text); |
| 1969 | } |
| 1970 | }; |
| 1971 | |
| 1972 | /* CSS rule representation. */ |
| 1973 | class CSSRule final : public JSON::ObjectBase { |
| 1974 | public: |
| 1975 | enum { |
| 1976 | NoFieldsSet = 0, |
| 1977 | SelectorListSet = 1 << 0, |
| 1978 | SourceLineSet = 1 << 1, |
| 1979 | OriginSet = 1 << 2, |
| 1980 | StyleSet = 1 << 3, |
| 1981 | AllFieldsSet = (SelectorListSet | SourceLineSet | OriginSet | StyleSet) |
| 1982 | }; |
| 1983 | |
| 1984 | template<int STATE> |
| 1985 | class Builder { |
| 1986 | private: |
| 1987 | RefPtr<JSON::Object> m_result; |
| 1988 | |
| 1989 | template<int STEP> Builder<STATE | STEP>& castState() |
| 1990 | { |
| 1991 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 1992 | } |
| 1993 | |
| 1994 | Builder(Ref</*CSSRule*/JSON::Object>&& object) |
| 1995 | : m_result(WTFMove(object)) |
| 1996 | { |
| 1997 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 1998 | } |
| 1999 | friend class CSSRule; |
| 2000 | public: |
| 2001 | |
| 2002 | Builder<STATE | SelectorListSet>& setSelectorList(Ref<Protocol::CSS::SelectorList>&& in_selectorList) |
| 2003 | { |
| 2004 | COMPILE_ASSERT(!(STATE & SelectorListSet), property_selectorList_already_set); |
| 2005 | m_result->setObject("selectorList"_s , WTFMove(in_selectorList)); |
| 2006 | return castState<SelectorListSet>(); |
| 2007 | } |
| 2008 | |
| 2009 | Builder<STATE | SourceLineSet>& setSourceLine(int in_sourceLine) |
| 2010 | { |
| 2011 | COMPILE_ASSERT(!(STATE & SourceLineSet), property_sourceLine_already_set); |
| 2012 | m_result->setInteger("sourceLine"_s , in_sourceLine); |
| 2013 | return castState<SourceLineSet>(); |
| 2014 | } |
| 2015 | |
| 2016 | Builder<STATE | OriginSet>& setOrigin(Protocol::CSS::StyleSheetOrigin in_origin) |
| 2017 | { |
| 2018 | COMPILE_ASSERT(!(STATE & OriginSet), property_origin_already_set); |
| 2019 | m_result->setString("origin"_s , Protocol::Helpers::getEnumConstantValue(in_origin)); |
| 2020 | return castState<OriginSet>(); |
| 2021 | } |
| 2022 | |
| 2023 | Builder<STATE | StyleSet>& setStyle(Ref<Protocol::CSS::CSSStyle>&& in_style) |
| 2024 | { |
| 2025 | COMPILE_ASSERT(!(STATE & StyleSet), property_style_already_set); |
| 2026 | m_result->setObject("style"_s , WTFMove(in_style)); |
| 2027 | return castState<StyleSet>(); |
| 2028 | } |
| 2029 | |
| 2030 | Ref<CSSRule> release() |
| 2031 | { |
| 2032 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2033 | COMPILE_ASSERT(sizeof(CSSRule) == sizeof(JSON::Object), cannot_cast); |
| 2034 | |
| 2035 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2036 | auto result = WTFMove(*reinterpret_cast<Ref<CSSRule>*>(&jsonResult)); |
| 2037 | return result; |
| 2038 | } |
| 2039 | }; |
| 2040 | |
| 2041 | /* |
| 2042 | * Synthetic constructor: |
| 2043 | * Ref<CSSRule> result = CSSRule::create() |
| 2044 | * .setSelectorList(...) |
| 2045 | * .setSourceLine(...) |
| 2046 | * .setOrigin(...) |
| 2047 | * .setStyle(...) |
| 2048 | * .release(); |
| 2049 | */ |
| 2050 | static Builder<NoFieldsSet> create() |
| 2051 | { |
| 2052 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2053 | } |
| 2054 | |
| 2055 | void setRuleId(Ref<Protocol::CSS::CSSRuleId>&& in_opt_ruleId) |
| 2056 | { |
| 2057 | JSON::ObjectBase::setObject("ruleId"_s , WTFMove(in_opt_ruleId)); |
| 2058 | } |
| 2059 | |
| 2060 | void setSourceURL(const String& in_opt_sourceURL) |
| 2061 | { |
| 2062 | JSON::ObjectBase::setString("sourceURL"_s , in_opt_sourceURL); |
| 2063 | } |
| 2064 | |
| 2065 | void setGroupings(Ref<JSON::ArrayOf<Protocol::CSS::Grouping>>&& in_opt_groupings) |
| 2066 | { |
| 2067 | JSON::ObjectBase::setArray("groupings"_s , WTFMove(in_opt_groupings)); |
| 2068 | } |
| 2069 | }; |
| 2070 | |
| 2071 | /* Text range within a resource. */ |
| 2072 | class SourceRange final : public JSON::ObjectBase { |
| 2073 | public: |
| 2074 | enum { |
| 2075 | NoFieldsSet = 0, |
| 2076 | StartLineSet = 1 << 0, |
| 2077 | StartColumnSet = 1 << 1, |
| 2078 | EndLineSet = 1 << 2, |
| 2079 | EndColumnSet = 1 << 3, |
| 2080 | AllFieldsSet = (StartLineSet | StartColumnSet | EndLineSet | EndColumnSet) |
| 2081 | }; |
| 2082 | |
| 2083 | template<int STATE> |
| 2084 | class Builder { |
| 2085 | private: |
| 2086 | RefPtr<JSON::Object> m_result; |
| 2087 | |
| 2088 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2089 | { |
| 2090 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2091 | } |
| 2092 | |
| 2093 | Builder(Ref</*SourceRange*/JSON::Object>&& object) |
| 2094 | : m_result(WTFMove(object)) |
| 2095 | { |
| 2096 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2097 | } |
| 2098 | friend class SourceRange; |
| 2099 | public: |
| 2100 | |
| 2101 | Builder<STATE | StartLineSet>& setStartLine(int in_startLine) |
| 2102 | { |
| 2103 | COMPILE_ASSERT(!(STATE & StartLineSet), property_startLine_already_set); |
| 2104 | m_result->setInteger("startLine"_s , in_startLine); |
| 2105 | return castState<StartLineSet>(); |
| 2106 | } |
| 2107 | |
| 2108 | Builder<STATE | StartColumnSet>& setStartColumn(int in_startColumn) |
| 2109 | { |
| 2110 | COMPILE_ASSERT(!(STATE & StartColumnSet), property_startColumn_already_set); |
| 2111 | m_result->setInteger("startColumn"_s , in_startColumn); |
| 2112 | return castState<StartColumnSet>(); |
| 2113 | } |
| 2114 | |
| 2115 | Builder<STATE | EndLineSet>& setEndLine(int in_endLine) |
| 2116 | { |
| 2117 | COMPILE_ASSERT(!(STATE & EndLineSet), property_endLine_already_set); |
| 2118 | m_result->setInteger("endLine"_s , in_endLine); |
| 2119 | return castState<EndLineSet>(); |
| 2120 | } |
| 2121 | |
| 2122 | Builder<STATE | EndColumnSet>& setEndColumn(int in_endColumn) |
| 2123 | { |
| 2124 | COMPILE_ASSERT(!(STATE & EndColumnSet), property_endColumn_already_set); |
| 2125 | m_result->setInteger("endColumn"_s , in_endColumn); |
| 2126 | return castState<EndColumnSet>(); |
| 2127 | } |
| 2128 | |
| 2129 | Ref<SourceRange> release() |
| 2130 | { |
| 2131 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2132 | COMPILE_ASSERT(sizeof(SourceRange) == sizeof(JSON::Object), cannot_cast); |
| 2133 | |
| 2134 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2135 | auto result = WTFMove(*reinterpret_cast<Ref<SourceRange>*>(&jsonResult)); |
| 2136 | return result; |
| 2137 | } |
| 2138 | }; |
| 2139 | |
| 2140 | /* |
| 2141 | * Synthetic constructor: |
| 2142 | * Ref<SourceRange> result = SourceRange::create() |
| 2143 | * .setStartLine(...) |
| 2144 | * .setStartColumn(...) |
| 2145 | * .setEndLine(...) |
| 2146 | * .setEndColumn(...) |
| 2147 | * .release(); |
| 2148 | */ |
| 2149 | static Builder<NoFieldsSet> create() |
| 2150 | { |
| 2151 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2152 | } |
| 2153 | }; |
| 2154 | |
| 2155 | class ShorthandEntry final : public JSON::ObjectBase { |
| 2156 | public: |
| 2157 | enum { |
| 2158 | NoFieldsSet = 0, |
| 2159 | NameSet = 1 << 0, |
| 2160 | ValueSet = 1 << 1, |
| 2161 | AllFieldsSet = (NameSet | ValueSet) |
| 2162 | }; |
| 2163 | |
| 2164 | template<int STATE> |
| 2165 | class Builder { |
| 2166 | private: |
| 2167 | RefPtr<JSON::Object> m_result; |
| 2168 | |
| 2169 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2170 | { |
| 2171 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2172 | } |
| 2173 | |
| 2174 | Builder(Ref</*ShorthandEntry*/JSON::Object>&& object) |
| 2175 | : m_result(WTFMove(object)) |
| 2176 | { |
| 2177 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2178 | } |
| 2179 | friend class ShorthandEntry; |
| 2180 | public: |
| 2181 | |
| 2182 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 2183 | { |
| 2184 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 2185 | m_result->setString("name"_s , in_name); |
| 2186 | return castState<NameSet>(); |
| 2187 | } |
| 2188 | |
| 2189 | Builder<STATE | ValueSet>& setValue(const String& in_value) |
| 2190 | { |
| 2191 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 2192 | m_result->setString("value"_s , in_value); |
| 2193 | return castState<ValueSet>(); |
| 2194 | } |
| 2195 | |
| 2196 | Ref<ShorthandEntry> release() |
| 2197 | { |
| 2198 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2199 | COMPILE_ASSERT(sizeof(ShorthandEntry) == sizeof(JSON::Object), cannot_cast); |
| 2200 | |
| 2201 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2202 | auto result = WTFMove(*reinterpret_cast<Ref<ShorthandEntry>*>(&jsonResult)); |
| 2203 | return result; |
| 2204 | } |
| 2205 | }; |
| 2206 | |
| 2207 | /* |
| 2208 | * Synthetic constructor: |
| 2209 | * Ref<ShorthandEntry> result = ShorthandEntry::create() |
| 2210 | * .setName(...) |
| 2211 | * .setValue(...) |
| 2212 | * .release(); |
| 2213 | */ |
| 2214 | static Builder<NoFieldsSet> create() |
| 2215 | { |
| 2216 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2217 | } |
| 2218 | }; |
| 2219 | |
| 2220 | class CSSPropertyInfo final : public JSON::ObjectBase { |
| 2221 | public: |
| 2222 | enum { |
| 2223 | NoFieldsSet = 0, |
| 2224 | NameSet = 1 << 0, |
| 2225 | AllFieldsSet = (NameSet) |
| 2226 | }; |
| 2227 | |
| 2228 | template<int STATE> |
| 2229 | class Builder { |
| 2230 | private: |
| 2231 | RefPtr<JSON::Object> m_result; |
| 2232 | |
| 2233 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2234 | { |
| 2235 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2236 | } |
| 2237 | |
| 2238 | Builder(Ref</*CSSPropertyInfo*/JSON::Object>&& object) |
| 2239 | : m_result(WTFMove(object)) |
| 2240 | { |
| 2241 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2242 | } |
| 2243 | friend class CSSPropertyInfo; |
| 2244 | public: |
| 2245 | |
| 2246 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 2247 | { |
| 2248 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 2249 | m_result->setString("name"_s , in_name); |
| 2250 | return castState<NameSet>(); |
| 2251 | } |
| 2252 | |
| 2253 | Ref<CSSPropertyInfo> release() |
| 2254 | { |
| 2255 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2256 | COMPILE_ASSERT(sizeof(CSSPropertyInfo) == sizeof(JSON::Object), cannot_cast); |
| 2257 | |
| 2258 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2259 | auto result = WTFMove(*reinterpret_cast<Ref<CSSPropertyInfo>*>(&jsonResult)); |
| 2260 | return result; |
| 2261 | } |
| 2262 | }; |
| 2263 | |
| 2264 | /* |
| 2265 | * Synthetic constructor: |
| 2266 | * Ref<CSSPropertyInfo> result = CSSPropertyInfo::create() |
| 2267 | * .setName(...) |
| 2268 | * .release(); |
| 2269 | */ |
| 2270 | static Builder<NoFieldsSet> create() |
| 2271 | { |
| 2272 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2273 | } |
| 2274 | |
| 2275 | void setAliases(Ref<JSON::ArrayOf<String>>&& in_opt_aliases) |
| 2276 | { |
| 2277 | JSON::ObjectBase::setArray("aliases"_s , WTFMove(in_opt_aliases)); |
| 2278 | } |
| 2279 | |
| 2280 | void setLonghands(Ref<JSON::ArrayOf<String>>&& in_opt_longhands) |
| 2281 | { |
| 2282 | JSON::ObjectBase::setArray("longhands"_s , WTFMove(in_opt_longhands)); |
| 2283 | } |
| 2284 | |
| 2285 | void setValues(Ref<JSON::ArrayOf<String>>&& in_opt_values) |
| 2286 | { |
| 2287 | JSON::ObjectBase::setArray("values"_s , WTFMove(in_opt_values)); |
| 2288 | } |
| 2289 | |
| 2290 | void setInherited(bool in_opt_inherited) |
| 2291 | { |
| 2292 | JSON::ObjectBase::setBoolean("inherited"_s , in_opt_inherited); |
| 2293 | } |
| 2294 | }; |
| 2295 | |
| 2296 | class CSSComputedStyleProperty final : public JSON::ObjectBase { |
| 2297 | public: |
| 2298 | enum { |
| 2299 | NoFieldsSet = 0, |
| 2300 | NameSet = 1 << 0, |
| 2301 | ValueSet = 1 << 1, |
| 2302 | AllFieldsSet = (NameSet | ValueSet) |
| 2303 | }; |
| 2304 | |
| 2305 | template<int STATE> |
| 2306 | class Builder { |
| 2307 | private: |
| 2308 | RefPtr<JSON::Object> m_result; |
| 2309 | |
| 2310 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2311 | { |
| 2312 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2313 | } |
| 2314 | |
| 2315 | Builder(Ref</*CSSComputedStyleProperty*/JSON::Object>&& object) |
| 2316 | : m_result(WTFMove(object)) |
| 2317 | { |
| 2318 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2319 | } |
| 2320 | friend class CSSComputedStyleProperty; |
| 2321 | public: |
| 2322 | |
| 2323 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 2324 | { |
| 2325 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 2326 | m_result->setString("name"_s , in_name); |
| 2327 | return castState<NameSet>(); |
| 2328 | } |
| 2329 | |
| 2330 | Builder<STATE | ValueSet>& setValue(const String& in_value) |
| 2331 | { |
| 2332 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 2333 | m_result->setString("value"_s , in_value); |
| 2334 | return castState<ValueSet>(); |
| 2335 | } |
| 2336 | |
| 2337 | Ref<CSSComputedStyleProperty> release() |
| 2338 | { |
| 2339 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2340 | COMPILE_ASSERT(sizeof(CSSComputedStyleProperty) == sizeof(JSON::Object), cannot_cast); |
| 2341 | |
| 2342 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2343 | auto result = WTFMove(*reinterpret_cast<Ref<CSSComputedStyleProperty>*>(&jsonResult)); |
| 2344 | return result; |
| 2345 | } |
| 2346 | }; |
| 2347 | |
| 2348 | /* |
| 2349 | * Synthetic constructor: |
| 2350 | * Ref<CSSComputedStyleProperty> result = CSSComputedStyleProperty::create() |
| 2351 | * .setName(...) |
| 2352 | * .setValue(...) |
| 2353 | * .release(); |
| 2354 | */ |
| 2355 | static Builder<NoFieldsSet> create() |
| 2356 | { |
| 2357 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2358 | } |
| 2359 | }; |
| 2360 | |
| 2361 | /* CSS style representation. */ |
| 2362 | class CSSStyle final : public JSON::ObjectBase { |
| 2363 | public: |
| 2364 | enum { |
| 2365 | NoFieldsSet = 0, |
| 2366 | CssPropertiesSet = 1 << 0, |
| 2367 | ShorthandEntriesSet = 1 << 1, |
| 2368 | AllFieldsSet = (CssPropertiesSet | ShorthandEntriesSet) |
| 2369 | }; |
| 2370 | |
| 2371 | template<int STATE> |
| 2372 | class Builder { |
| 2373 | private: |
| 2374 | RefPtr<JSON::Object> m_result; |
| 2375 | |
| 2376 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2377 | { |
| 2378 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2379 | } |
| 2380 | |
| 2381 | Builder(Ref</*CSSStyle*/JSON::Object>&& object) |
| 2382 | : m_result(WTFMove(object)) |
| 2383 | { |
| 2384 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2385 | } |
| 2386 | friend class CSSStyle; |
| 2387 | public: |
| 2388 | |
| 2389 | Builder<STATE | CssPropertiesSet>& setCssProperties(Ref<JSON::ArrayOf<Protocol::CSS::CSSProperty>>&& in_cssProperties) |
| 2390 | { |
| 2391 | COMPILE_ASSERT(!(STATE & CssPropertiesSet), property_cssProperties_already_set); |
| 2392 | m_result->setArray("cssProperties"_s , WTFMove(in_cssProperties)); |
| 2393 | return castState<CssPropertiesSet>(); |
| 2394 | } |
| 2395 | |
| 2396 | Builder<STATE | ShorthandEntriesSet>& setShorthandEntries(Ref<JSON::ArrayOf<Protocol::CSS::ShorthandEntry>>&& in_shorthandEntries) |
| 2397 | { |
| 2398 | COMPILE_ASSERT(!(STATE & ShorthandEntriesSet), property_shorthandEntries_already_set); |
| 2399 | m_result->setArray("shorthandEntries"_s , WTFMove(in_shorthandEntries)); |
| 2400 | return castState<ShorthandEntriesSet>(); |
| 2401 | } |
| 2402 | |
| 2403 | Ref<CSSStyle> release() |
| 2404 | { |
| 2405 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2406 | COMPILE_ASSERT(sizeof(CSSStyle) == sizeof(JSON::Object), cannot_cast); |
| 2407 | |
| 2408 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2409 | auto result = WTFMove(*reinterpret_cast<Ref<CSSStyle>*>(&jsonResult)); |
| 2410 | return result; |
| 2411 | } |
| 2412 | }; |
| 2413 | |
| 2414 | /* |
| 2415 | * Synthetic constructor: |
| 2416 | * Ref<CSSStyle> result = CSSStyle::create() |
| 2417 | * .setCssProperties(...) |
| 2418 | * .setShorthandEntries(...) |
| 2419 | * .release(); |
| 2420 | */ |
| 2421 | static Builder<NoFieldsSet> create() |
| 2422 | { |
| 2423 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2424 | } |
| 2425 | |
| 2426 | void setStyleId(Ref<Protocol::CSS::CSSStyleId>&& in_opt_styleId) |
| 2427 | { |
| 2428 | JSON::ObjectBase::setObject("styleId"_s , WTFMove(in_opt_styleId)); |
| 2429 | } |
| 2430 | |
| 2431 | void setCssText(const String& in_opt_cssText) |
| 2432 | { |
| 2433 | JSON::ObjectBase::setString("cssText"_s , in_opt_cssText); |
| 2434 | } |
| 2435 | |
| 2436 | void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range) |
| 2437 | { |
| 2438 | JSON::ObjectBase::setObject("range"_s , WTFMove(in_opt_range)); |
| 2439 | } |
| 2440 | |
| 2441 | void setWidth(const String& in_opt_width) |
| 2442 | { |
| 2443 | JSON::ObjectBase::setString("width"_s , in_opt_width); |
| 2444 | } |
| 2445 | |
| 2446 | void setHeight(const String& in_opt_height) |
| 2447 | { |
| 2448 | JSON::ObjectBase::setString("height"_s , in_opt_height); |
| 2449 | } |
| 2450 | }; |
| 2451 | |
| 2452 | /* The property status: "active" if the property is effective in the style, "inactive" if the property is overridden by a same-named property in this style later on, "disabled" if the property is disabled by the user, "style" (implied if absent) if the property is reported by the browser rather than by the CSS source parser. */ |
| 2453 | enum class CSSPropertyStatus { |
| 2454 | Active = 2, |
| 2455 | Inactive = 34, |
| 2456 | Disabled = 35, |
| 2457 | Style = 36, |
| 2458 | }; // enum class CSSPropertyStatus |
| 2459 | |
| 2460 | /* CSS style effective visual dimensions and source offsets. */ |
| 2461 | class CSSProperty final : public JSON::Object { |
| 2462 | public: |
| 2463 | enum { |
| 2464 | NoFieldsSet = 0, |
| 2465 | NameSet = 1 << 0, |
| 2466 | ValueSet = 1 << 1, |
| 2467 | AllFieldsSet = (NameSet | ValueSet) |
| 2468 | }; |
| 2469 | |
| 2470 | template<int STATE> |
| 2471 | class Builder { |
| 2472 | private: |
| 2473 | RefPtr<JSON::Object> m_result; |
| 2474 | |
| 2475 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2476 | { |
| 2477 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2478 | } |
| 2479 | |
| 2480 | Builder(Ref</*CSSProperty*/JSON::Object>&& object) |
| 2481 | : m_result(WTFMove(object)) |
| 2482 | { |
| 2483 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2484 | } |
| 2485 | friend class CSSProperty; |
| 2486 | public: |
| 2487 | |
| 2488 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 2489 | { |
| 2490 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 2491 | m_result->setString("name"_s , in_name); |
| 2492 | return castState<NameSet>(); |
| 2493 | } |
| 2494 | |
| 2495 | Builder<STATE | ValueSet>& setValue(const String& in_value) |
| 2496 | { |
| 2497 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 2498 | m_result->setString("value"_s , in_value); |
| 2499 | return castState<ValueSet>(); |
| 2500 | } |
| 2501 | |
| 2502 | Ref<CSSProperty> release() |
| 2503 | { |
| 2504 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2505 | COMPILE_ASSERT(sizeof(CSSProperty) == sizeof(JSON::Object), cannot_cast); |
| 2506 | |
| 2507 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2508 | auto result = WTFMove(*reinterpret_cast<Ref<CSSProperty>*>(&jsonResult)); |
| 2509 | return result; |
| 2510 | } |
| 2511 | }; |
| 2512 | |
| 2513 | /* |
| 2514 | * Synthetic constructor: |
| 2515 | * Ref<CSSProperty> result = CSSProperty::create() |
| 2516 | * .setName(...) |
| 2517 | * .setValue(...) |
| 2518 | * .release(); |
| 2519 | */ |
| 2520 | static Builder<NoFieldsSet> create() |
| 2521 | { |
| 2522 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2523 | } |
| 2524 | |
| 2525 | void setPriority(const String& in_opt_priority) |
| 2526 | { |
| 2527 | JSON::ObjectBase::setString("priority"_s , in_opt_priority); |
| 2528 | } |
| 2529 | |
| 2530 | void setImplicit(bool in_opt_implicit) |
| 2531 | { |
| 2532 | JSON::ObjectBase::setBoolean("implicit"_s , in_opt_implicit); |
| 2533 | } |
| 2534 | |
| 2535 | void setText(const String& in_opt_text) |
| 2536 | { |
| 2537 | JSON::ObjectBase::setString("text"_s , in_opt_text); |
| 2538 | } |
| 2539 | |
| 2540 | void setParsedOk(bool in_opt_parsedOk) |
| 2541 | { |
| 2542 | JSON::ObjectBase::setBoolean("parsedOk"_s , in_opt_parsedOk); |
| 2543 | } |
| 2544 | |
| 2545 | void setStatus(Protocol::CSS::CSSPropertyStatus in_opt_status) |
| 2546 | { |
| 2547 | JSON::ObjectBase::setString("status"_s , Protocol::Helpers::getEnumConstantValue(in_opt_status)); |
| 2548 | } |
| 2549 | |
| 2550 | void setRange(Ref<Protocol::CSS::SourceRange>&& in_opt_range) |
| 2551 | { |
| 2552 | JSON::ObjectBase::setObject("range"_s , WTFMove(in_opt_range)); |
| 2553 | } |
| 2554 | |
| 2555 | // Property names for type generated as open. |
| 2556 | JS_EXPORT_PRIVATE static const ASCIILiteral priorityKey; |
| 2557 | JS_EXPORT_PRIVATE static const ASCIILiteral parsedOkKey; |
| 2558 | JS_EXPORT_PRIVATE static const ASCIILiteral statusKey; |
| 2559 | }; |
| 2560 | |
| 2561 | /* CSS @media (as well as other users of media queries, like @import, <style>, <link>, etc.) and @supports descriptor. */ |
| 2562 | class Grouping final : public JSON::ObjectBase { |
| 2563 | public: |
| 2564 | // Named after property name 'type' while generating Grouping. |
| 2565 | enum class Type { |
| 2566 | MediaRule = 37, |
| 2567 | MediaImportRule = 38, |
| 2568 | MediaLinkNode = 39, |
| 2569 | MediaStyleNode = 40, |
| 2570 | SupportsRule = 41, |
| 2571 | }; // enum class Type |
| 2572 | |
| 2573 | enum { |
| 2574 | NoFieldsSet = 0, |
| 2575 | TextSet = 1 << 0, |
| 2576 | TypeSet = 1 << 1, |
| 2577 | AllFieldsSet = (TextSet | TypeSet) |
| 2578 | }; |
| 2579 | |
| 2580 | template<int STATE> |
| 2581 | class Builder { |
| 2582 | private: |
| 2583 | RefPtr<JSON::Object> m_result; |
| 2584 | |
| 2585 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2586 | { |
| 2587 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2588 | } |
| 2589 | |
| 2590 | Builder(Ref</*Grouping*/JSON::Object>&& object) |
| 2591 | : m_result(WTFMove(object)) |
| 2592 | { |
| 2593 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2594 | } |
| 2595 | friend class Grouping; |
| 2596 | public: |
| 2597 | |
| 2598 | Builder<STATE | TextSet>& setText(const String& in_text) |
| 2599 | { |
| 2600 | COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set); |
| 2601 | m_result->setString("text"_s , in_text); |
| 2602 | return castState<TextSet>(); |
| 2603 | } |
| 2604 | |
| 2605 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 2606 | { |
| 2607 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 2608 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 2609 | return castState<TypeSet>(); |
| 2610 | } |
| 2611 | |
| 2612 | Ref<Grouping> release() |
| 2613 | { |
| 2614 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2615 | COMPILE_ASSERT(sizeof(Grouping) == sizeof(JSON::Object), cannot_cast); |
| 2616 | |
| 2617 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2618 | auto result = WTFMove(*reinterpret_cast<Ref<Grouping>*>(&jsonResult)); |
| 2619 | return result; |
| 2620 | } |
| 2621 | }; |
| 2622 | |
| 2623 | /* |
| 2624 | * Synthetic constructor: |
| 2625 | * Ref<Grouping> result = Grouping::create() |
| 2626 | * .setText(...) |
| 2627 | * .setType(...) |
| 2628 | * .release(); |
| 2629 | */ |
| 2630 | static Builder<NoFieldsSet> create() |
| 2631 | { |
| 2632 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2633 | } |
| 2634 | |
| 2635 | void setSourceURL(const String& in_opt_sourceURL) |
| 2636 | { |
| 2637 | JSON::ObjectBase::setString("sourceURL"_s , in_opt_sourceURL); |
| 2638 | } |
| 2639 | }; |
| 2640 | |
| 2641 | /* A representation of WebCore::Font. Conceptually this is backed by either a font file on disk or from the network. */ |
| 2642 | class Font final : public JSON::ObjectBase { |
| 2643 | public: |
| 2644 | enum { |
| 2645 | NoFieldsSet = 0, |
| 2646 | DisplayNameSet = 1 << 0, |
| 2647 | VariationAxesSet = 1 << 1, |
| 2648 | AllFieldsSet = (DisplayNameSet | VariationAxesSet) |
| 2649 | }; |
| 2650 | |
| 2651 | template<int STATE> |
| 2652 | class Builder { |
| 2653 | private: |
| 2654 | RefPtr<JSON::Object> m_result; |
| 2655 | |
| 2656 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2657 | { |
| 2658 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2659 | } |
| 2660 | |
| 2661 | Builder(Ref</*Font*/JSON::Object>&& object) |
| 2662 | : m_result(WTFMove(object)) |
| 2663 | { |
| 2664 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2665 | } |
| 2666 | friend class Font; |
| 2667 | public: |
| 2668 | |
| 2669 | Builder<STATE | DisplayNameSet>& setDisplayName(const String& in_displayName) |
| 2670 | { |
| 2671 | COMPILE_ASSERT(!(STATE & DisplayNameSet), property_displayName_already_set); |
| 2672 | m_result->setString("displayName"_s , in_displayName); |
| 2673 | return castState<DisplayNameSet>(); |
| 2674 | } |
| 2675 | |
| 2676 | Builder<STATE | VariationAxesSet>& setVariationAxes(Ref<JSON::ArrayOf<Protocol::CSS::FontVariationAxis>>&& in_variationAxes) |
| 2677 | { |
| 2678 | COMPILE_ASSERT(!(STATE & VariationAxesSet), property_variationAxes_already_set); |
| 2679 | m_result->setArray("variationAxes"_s , WTFMove(in_variationAxes)); |
| 2680 | return castState<VariationAxesSet>(); |
| 2681 | } |
| 2682 | |
| 2683 | Ref<Font> release() |
| 2684 | { |
| 2685 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2686 | COMPILE_ASSERT(sizeof(Font) == sizeof(JSON::Object), cannot_cast); |
| 2687 | |
| 2688 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2689 | auto result = WTFMove(*reinterpret_cast<Ref<Font>*>(&jsonResult)); |
| 2690 | return result; |
| 2691 | } |
| 2692 | }; |
| 2693 | |
| 2694 | /* |
| 2695 | * Synthetic constructor: |
| 2696 | * Ref<Font> result = Font::create() |
| 2697 | * .setDisplayName(...) |
| 2698 | * .setVariationAxes(...) |
| 2699 | * .release(); |
| 2700 | */ |
| 2701 | static Builder<NoFieldsSet> create() |
| 2702 | { |
| 2703 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2704 | } |
| 2705 | }; |
| 2706 | |
| 2707 | /* A single variation axis associated with a Font. */ |
| 2708 | class FontVariationAxis final : public JSON::ObjectBase { |
| 2709 | public: |
| 2710 | enum { |
| 2711 | NoFieldsSet = 0, |
| 2712 | TagSet = 1 << 0, |
| 2713 | MinimumValueSet = 1 << 1, |
| 2714 | MaximumValueSet = 1 << 2, |
| 2715 | DefaultValueSet = 1 << 3, |
| 2716 | AllFieldsSet = (TagSet | MinimumValueSet | MaximumValueSet | DefaultValueSet) |
| 2717 | }; |
| 2718 | |
| 2719 | template<int STATE> |
| 2720 | class Builder { |
| 2721 | private: |
| 2722 | RefPtr<JSON::Object> m_result; |
| 2723 | |
| 2724 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2725 | { |
| 2726 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2727 | } |
| 2728 | |
| 2729 | Builder(Ref</*FontVariationAxis*/JSON::Object>&& object) |
| 2730 | : m_result(WTFMove(object)) |
| 2731 | { |
| 2732 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2733 | } |
| 2734 | friend class FontVariationAxis; |
| 2735 | public: |
| 2736 | |
| 2737 | Builder<STATE | TagSet>& setTag(const String& in_tag) |
| 2738 | { |
| 2739 | COMPILE_ASSERT(!(STATE & TagSet), property_tag_already_set); |
| 2740 | m_result->setString("tag"_s , in_tag); |
| 2741 | return castState<TagSet>(); |
| 2742 | } |
| 2743 | |
| 2744 | Builder<STATE | MinimumValueSet>& setMinimumValue(double in_minimumValue) |
| 2745 | { |
| 2746 | COMPILE_ASSERT(!(STATE & MinimumValueSet), property_minimumValue_already_set); |
| 2747 | m_result->setDouble("minimumValue"_s , in_minimumValue); |
| 2748 | return castState<MinimumValueSet>(); |
| 2749 | } |
| 2750 | |
| 2751 | Builder<STATE | MaximumValueSet>& setMaximumValue(double in_maximumValue) |
| 2752 | { |
| 2753 | COMPILE_ASSERT(!(STATE & MaximumValueSet), property_maximumValue_already_set); |
| 2754 | m_result->setDouble("maximumValue"_s , in_maximumValue); |
| 2755 | return castState<MaximumValueSet>(); |
| 2756 | } |
| 2757 | |
| 2758 | Builder<STATE | DefaultValueSet>& setDefaultValue(double in_defaultValue) |
| 2759 | { |
| 2760 | COMPILE_ASSERT(!(STATE & DefaultValueSet), property_defaultValue_already_set); |
| 2761 | m_result->setDouble("defaultValue"_s , in_defaultValue); |
| 2762 | return castState<DefaultValueSet>(); |
| 2763 | } |
| 2764 | |
| 2765 | Ref<FontVariationAxis> release() |
| 2766 | { |
| 2767 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2768 | COMPILE_ASSERT(sizeof(FontVariationAxis) == sizeof(JSON::Object), cannot_cast); |
| 2769 | |
| 2770 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2771 | auto result = WTFMove(*reinterpret_cast<Ref<FontVariationAxis>*>(&jsonResult)); |
| 2772 | return result; |
| 2773 | } |
| 2774 | }; |
| 2775 | |
| 2776 | /* |
| 2777 | * Synthetic constructor: |
| 2778 | * Ref<FontVariationAxis> result = FontVariationAxis::create() |
| 2779 | * .setTag(...) |
| 2780 | * .setMinimumValue(...) |
| 2781 | * .setMaximumValue(...) |
| 2782 | * .setDefaultValue(...) |
| 2783 | * .release(); |
| 2784 | */ |
| 2785 | static Builder<NoFieldsSet> create() |
| 2786 | { |
| 2787 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2788 | } |
| 2789 | |
| 2790 | void setName(const String& in_opt_name) |
| 2791 | { |
| 2792 | JSON::ObjectBase::setString("name"_s , in_opt_name); |
| 2793 | } |
| 2794 | }; |
| 2795 | |
| 2796 | /* The layout context type of a node. */ |
| 2797 | enum class LayoutContextType { |
| 2798 | Grid = 42, |
| 2799 | }; // enum class LayoutContextType |
| 2800 | |
| 2801 | /* The mode for how layout context type changes are handled (default: <code>Observed</code>). <code>Observed</code> limits handling to those nodes already known to the frontend by other means (generally, this means the node is a visible item in the Elements tab). <code>All</code> informs the frontend of all layout context type changes and all nodes with a known layout context are sent to the frontend. */ |
| 2802 | enum class LayoutContextTypeChangedMode { |
| 2803 | Observed = 43, |
| 2804 | All = 44, |
| 2805 | }; // enum class LayoutContextTypeChangedMode |
| 2806 | |
| 2807 | } // CSS |
| 2808 | |
| 2809 | namespace Canvas { |
| 2810 | |
| 2811 | /* The type of rendering context backing the canvas element. */ |
| 2812 | enum class ContextType { |
| 2813 | Canvas2D = 45, |
| 2814 | BitmapRenderer = 46, |
| 2815 | WebGL = 47, |
| 2816 | WebGL2 = 48, |
| 2817 | WebGPU = 49, |
| 2818 | }; // enum class ContextType |
| 2819 | |
| 2820 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 2821 | enum class ProgramType { |
| 2822 | Compute = 50, |
| 2823 | Render = 51, |
| 2824 | }; // enum class ProgramType |
| 2825 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 2826 | |
| 2827 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 2828 | enum class ShaderType { |
| 2829 | Compute = 50, |
| 2830 | Fragment = 52, |
| 2831 | Vertex = 53, |
| 2832 | }; // enum class ShaderType |
| 2833 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 2834 | |
| 2835 | /* Drawing surface attributes. */ |
| 2836 | class ContextAttributes final : public JSON::ObjectBase { |
| 2837 | public: |
| 2838 | enum { |
| 2839 | NoFieldsSet = 0, |
| 2840 | AllFieldsSet = 0 |
| 2841 | }; |
| 2842 | |
| 2843 | template<int STATE> |
| 2844 | class Builder { |
| 2845 | private: |
| 2846 | RefPtr<JSON::Object> m_result; |
| 2847 | |
| 2848 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2849 | { |
| 2850 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2851 | } |
| 2852 | |
| 2853 | Builder(Ref</*ContextAttributes*/JSON::Object>&& object) |
| 2854 | : m_result(WTFMove(object)) |
| 2855 | { |
| 2856 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2857 | } |
| 2858 | friend class ContextAttributes; |
| 2859 | public: |
| 2860 | |
| 2861 | Ref<ContextAttributes> release() |
| 2862 | { |
| 2863 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2864 | COMPILE_ASSERT(sizeof(ContextAttributes) == sizeof(JSON::Object), cannot_cast); |
| 2865 | |
| 2866 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2867 | auto result = WTFMove(*reinterpret_cast<Ref<ContextAttributes>*>(&jsonResult)); |
| 2868 | return result; |
| 2869 | } |
| 2870 | }; |
| 2871 | |
| 2872 | /* |
| 2873 | * Synthetic constructor: |
| 2874 | * Ref<ContextAttributes> result = ContextAttributes::create() |
| 2875 | * .release(); |
| 2876 | */ |
| 2877 | static Builder<NoFieldsSet> create() |
| 2878 | { |
| 2879 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2880 | } |
| 2881 | |
| 2882 | void setAlpha(bool in_opt_alpha) |
| 2883 | { |
| 2884 | JSON::ObjectBase::setBoolean("alpha"_s , in_opt_alpha); |
| 2885 | } |
| 2886 | |
| 2887 | void setDepth(bool in_opt_depth) |
| 2888 | { |
| 2889 | JSON::ObjectBase::setBoolean("depth"_s , in_opt_depth); |
| 2890 | } |
| 2891 | |
| 2892 | void setStencil(bool in_opt_stencil) |
| 2893 | { |
| 2894 | JSON::ObjectBase::setBoolean("stencil"_s , in_opt_stencil); |
| 2895 | } |
| 2896 | |
| 2897 | void setAntialias(bool in_opt_antialias) |
| 2898 | { |
| 2899 | JSON::ObjectBase::setBoolean("antialias"_s , in_opt_antialias); |
| 2900 | } |
| 2901 | |
| 2902 | void setPremultipliedAlpha(bool in_opt_premultipliedAlpha) |
| 2903 | { |
| 2904 | JSON::ObjectBase::setBoolean("premultipliedAlpha"_s , in_opt_premultipliedAlpha); |
| 2905 | } |
| 2906 | |
| 2907 | void setPreserveDrawingBuffer(bool in_opt_preserveDrawingBuffer) |
| 2908 | { |
| 2909 | JSON::ObjectBase::setBoolean("preserveDrawingBuffer"_s , in_opt_preserveDrawingBuffer); |
| 2910 | } |
| 2911 | |
| 2912 | void setFailIfMajorPerformanceCaveat(bool in_opt_failIfMajorPerformanceCaveat) |
| 2913 | { |
| 2914 | JSON::ObjectBase::setBoolean("failIfMajorPerformanceCaveat"_s , in_opt_failIfMajorPerformanceCaveat); |
| 2915 | } |
| 2916 | |
| 2917 | void setPowerPreference(const String& in_opt_powerPreference) |
| 2918 | { |
| 2919 | JSON::ObjectBase::setString("powerPreference"_s , in_opt_powerPreference); |
| 2920 | } |
| 2921 | }; |
| 2922 | |
| 2923 | /* Information about a canvas for which a rendering context has been created. */ |
| 2924 | class Canvas final : public JSON::ObjectBase { |
| 2925 | public: |
| 2926 | enum { |
| 2927 | NoFieldsSet = 0, |
| 2928 | CanvasIdSet = 1 << 0, |
| 2929 | ContextTypeSet = 1 << 1, |
| 2930 | AllFieldsSet = (CanvasIdSet | ContextTypeSet) |
| 2931 | }; |
| 2932 | |
| 2933 | template<int STATE> |
| 2934 | class Builder { |
| 2935 | private: |
| 2936 | RefPtr<JSON::Object> m_result; |
| 2937 | |
| 2938 | template<int STEP> Builder<STATE | STEP>& castState() |
| 2939 | { |
| 2940 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 2941 | } |
| 2942 | |
| 2943 | Builder(Ref</*Canvas*/JSON::Object>&& object) |
| 2944 | : m_result(WTFMove(object)) |
| 2945 | { |
| 2946 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 2947 | } |
| 2948 | friend class Canvas; |
| 2949 | public: |
| 2950 | |
| 2951 | Builder<STATE | CanvasIdSet>& setCanvasId(const String& in_canvasId) |
| 2952 | { |
| 2953 | COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set); |
| 2954 | m_result->setString("canvasId"_s , in_canvasId); |
| 2955 | return castState<CanvasIdSet>(); |
| 2956 | } |
| 2957 | |
| 2958 | Builder<STATE | ContextTypeSet>& setContextType(Protocol::Canvas::ContextType in_contextType) |
| 2959 | { |
| 2960 | COMPILE_ASSERT(!(STATE & ContextTypeSet), property_contextType_already_set); |
| 2961 | m_result->setString("contextType"_s , Protocol::Helpers::getEnumConstantValue(in_contextType)); |
| 2962 | return castState<ContextTypeSet>(); |
| 2963 | } |
| 2964 | |
| 2965 | Ref<Canvas> release() |
| 2966 | { |
| 2967 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 2968 | COMPILE_ASSERT(sizeof(Canvas) == sizeof(JSON::Object), cannot_cast); |
| 2969 | |
| 2970 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 2971 | auto result = WTFMove(*reinterpret_cast<Ref<Canvas>*>(&jsonResult)); |
| 2972 | return result; |
| 2973 | } |
| 2974 | }; |
| 2975 | |
| 2976 | /* |
| 2977 | * Synthetic constructor: |
| 2978 | * Ref<Canvas> result = Canvas::create() |
| 2979 | * .setCanvasId(...) |
| 2980 | * .setContextType(...) |
| 2981 | * .release(); |
| 2982 | */ |
| 2983 | static Builder<NoFieldsSet> create() |
| 2984 | { |
| 2985 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 2986 | } |
| 2987 | |
| 2988 | void setNodeId(int in_opt_nodeId) |
| 2989 | { |
| 2990 | JSON::ObjectBase::setInteger("nodeId"_s , in_opt_nodeId); |
| 2991 | } |
| 2992 | |
| 2993 | void setCssCanvasName(const String& in_opt_cssCanvasName) |
| 2994 | { |
| 2995 | JSON::ObjectBase::setString("cssCanvasName"_s , in_opt_cssCanvasName); |
| 2996 | } |
| 2997 | |
| 2998 | void setContextAttributes(Ref<Protocol::Canvas::ContextAttributes>&& in_opt_contextAttributes) |
| 2999 | { |
| 3000 | JSON::ObjectBase::setObject("contextAttributes"_s , WTFMove(in_opt_contextAttributes)); |
| 3001 | } |
| 3002 | |
| 3003 | void setMemoryCost(double in_opt_memoryCost) |
| 3004 | { |
| 3005 | JSON::ObjectBase::setDouble("memoryCost"_s , in_opt_memoryCost); |
| 3006 | } |
| 3007 | |
| 3008 | void setBacktrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_backtrace) |
| 3009 | { |
| 3010 | JSON::ObjectBase::setArray("backtrace"_s , WTFMove(in_opt_backtrace)); |
| 3011 | } |
| 3012 | }; |
| 3013 | |
| 3014 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 3015 | /* Information about a WebGL/WebGL2 shader program or WebGPU shader pipeline. */ |
| 3016 | class ShaderProgram final : public JSON::ObjectBase { |
| 3017 | public: |
| 3018 | enum { |
| 3019 | NoFieldsSet = 0, |
| 3020 | ProgramIdSet = 1 << 0, |
| 3021 | ProgramTypeSet = 1 << 1, |
| 3022 | CanvasIdSet = 1 << 2, |
| 3023 | AllFieldsSet = (ProgramIdSet | ProgramTypeSet | CanvasIdSet) |
| 3024 | }; |
| 3025 | |
| 3026 | template<int STATE> |
| 3027 | class Builder { |
| 3028 | private: |
| 3029 | RefPtr<JSON::Object> m_result; |
| 3030 | |
| 3031 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3032 | { |
| 3033 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3034 | } |
| 3035 | |
| 3036 | Builder(Ref</*ShaderProgram*/JSON::Object>&& object) |
| 3037 | : m_result(WTFMove(object)) |
| 3038 | { |
| 3039 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3040 | } |
| 3041 | friend class ShaderProgram; |
| 3042 | public: |
| 3043 | |
| 3044 | Builder<STATE | ProgramIdSet>& setProgramId(const String& in_programId) |
| 3045 | { |
| 3046 | COMPILE_ASSERT(!(STATE & ProgramIdSet), property_programId_already_set); |
| 3047 | m_result->setString("programId"_s , in_programId); |
| 3048 | return castState<ProgramIdSet>(); |
| 3049 | } |
| 3050 | |
| 3051 | Builder<STATE | ProgramTypeSet>& setProgramType(Protocol::Canvas::ProgramType in_programType) |
| 3052 | { |
| 3053 | COMPILE_ASSERT(!(STATE & ProgramTypeSet), property_programType_already_set); |
| 3054 | m_result->setString("programType"_s , Protocol::Helpers::getEnumConstantValue(in_programType)); |
| 3055 | return castState<ProgramTypeSet>(); |
| 3056 | } |
| 3057 | |
| 3058 | Builder<STATE | CanvasIdSet>& setCanvasId(const String& in_canvasId) |
| 3059 | { |
| 3060 | COMPILE_ASSERT(!(STATE & CanvasIdSet), property_canvasId_already_set); |
| 3061 | m_result->setString("canvasId"_s , in_canvasId); |
| 3062 | return castState<CanvasIdSet>(); |
| 3063 | } |
| 3064 | |
| 3065 | Ref<ShaderProgram> release() |
| 3066 | { |
| 3067 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3068 | COMPILE_ASSERT(sizeof(ShaderProgram) == sizeof(JSON::Object), cannot_cast); |
| 3069 | |
| 3070 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3071 | auto result = WTFMove(*reinterpret_cast<Ref<ShaderProgram>*>(&jsonResult)); |
| 3072 | return result; |
| 3073 | } |
| 3074 | }; |
| 3075 | |
| 3076 | /* |
| 3077 | * Synthetic constructor: |
| 3078 | * Ref<ShaderProgram> result = ShaderProgram::create() |
| 3079 | * .setProgramId(...) |
| 3080 | * .setProgramType(...) |
| 3081 | * .setCanvasId(...) |
| 3082 | * .release(); |
| 3083 | */ |
| 3084 | static Builder<NoFieldsSet> create() |
| 3085 | { |
| 3086 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3087 | } |
| 3088 | |
| 3089 | void setSharesVertexFragmentShader(bool in_opt_sharesVertexFragmentShader) |
| 3090 | { |
| 3091 | JSON::ObjectBase::setBoolean("sharesVertexFragmentShader"_s , in_opt_sharesVertexFragmentShader); |
| 3092 | } |
| 3093 | }; |
| 3094 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 3095 | |
| 3096 | } // Canvas |
| 3097 | |
| 3098 | namespace Console { |
| 3099 | |
| 3100 | /* Channels for different types of log messages. */ |
| 3101 | enum class ChannelSource { |
| 3102 | XML = 54, |
| 3103 | JavaScript = 55, |
| 3104 | Network = 56, |
| 3105 | ConsoleAPI = 57, |
| 3106 | Storage = 58, |
| 3107 | Appcache = 59, |
| 3108 | Rendering = 60, |
| 3109 | CSS = 61, |
| 3110 | Security = 62, |
| 3111 | ContentBlocker = 63, |
| 3112 | Media = 64, |
| 3113 | MediaSource = 65, |
| 3114 | WebRTC = 66, |
| 3115 | ITPDebug = 67, |
| 3116 | PrivateClickMeasurement = 68, |
| 3117 | PaymentRequest = 69, |
| 3118 | Other = 70, |
| 3119 | }; // enum class ChannelSource |
| 3120 | |
| 3121 | /* Level of logging. */ |
| 3122 | enum class ChannelLevel { |
| 3123 | Off = 71, |
| 3124 | Basic = 72, |
| 3125 | Verbose = 73, |
| 3126 | }; // enum class ChannelLevel |
| 3127 | |
| 3128 | /* Logging channel. */ |
| 3129 | class Channel final : public JSON::ObjectBase { |
| 3130 | public: |
| 3131 | enum { |
| 3132 | NoFieldsSet = 0, |
| 3133 | SourceSet = 1 << 0, |
| 3134 | LevelSet = 1 << 1, |
| 3135 | AllFieldsSet = (SourceSet | LevelSet) |
| 3136 | }; |
| 3137 | |
| 3138 | template<int STATE> |
| 3139 | class Builder { |
| 3140 | private: |
| 3141 | RefPtr<JSON::Object> m_result; |
| 3142 | |
| 3143 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3144 | { |
| 3145 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3146 | } |
| 3147 | |
| 3148 | Builder(Ref</*Channel*/JSON::Object>&& object) |
| 3149 | : m_result(WTFMove(object)) |
| 3150 | { |
| 3151 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3152 | } |
| 3153 | friend class Channel; |
| 3154 | public: |
| 3155 | |
| 3156 | Builder<STATE | SourceSet>& setSource(Protocol::Console::ChannelSource in_source) |
| 3157 | { |
| 3158 | COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set); |
| 3159 | m_result->setString("source"_s , Protocol::Helpers::getEnumConstantValue(in_source)); |
| 3160 | return castState<SourceSet>(); |
| 3161 | } |
| 3162 | |
| 3163 | Builder<STATE | LevelSet>& setLevel(Protocol::Console::ChannelLevel in_level) |
| 3164 | { |
| 3165 | COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set); |
| 3166 | m_result->setString("level"_s , Protocol::Helpers::getEnumConstantValue(in_level)); |
| 3167 | return castState<LevelSet>(); |
| 3168 | } |
| 3169 | |
| 3170 | Ref<Channel> release() |
| 3171 | { |
| 3172 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3173 | COMPILE_ASSERT(sizeof(Channel) == sizeof(JSON::Object), cannot_cast); |
| 3174 | |
| 3175 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3176 | auto result = WTFMove(*reinterpret_cast<Ref<Channel>*>(&jsonResult)); |
| 3177 | return result; |
| 3178 | } |
| 3179 | }; |
| 3180 | |
| 3181 | /* |
| 3182 | * Synthetic constructor: |
| 3183 | * Ref<Channel> result = Channel::create() |
| 3184 | * .setSource(...) |
| 3185 | * .setLevel(...) |
| 3186 | * .release(); |
| 3187 | */ |
| 3188 | static Builder<NoFieldsSet> create() |
| 3189 | { |
| 3190 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3191 | } |
| 3192 | }; |
| 3193 | |
| 3194 | /* Console message. */ |
| 3195 | class ConsoleMessage final : public JSON::ObjectBase { |
| 3196 | public: |
| 3197 | // Named after property name 'level' while generating ConsoleMessage. |
| 3198 | enum class Level { |
| 3199 | Log = 74, |
| 3200 | Info = 75, |
| 3201 | Warning = 76, |
| 3202 | Error = 77, |
| 3203 | Debug = 78, |
| 3204 | }; // enum class Level |
| 3205 | |
| 3206 | // Named after property name 'type' while generating ConsoleMessage. |
| 3207 | enum class Type { |
| 3208 | Log = 74, |
| 3209 | Dir = 79, |
| 3210 | DirXML = 80, |
| 3211 | Table = 81, |
| 3212 | Trace = 82, |
| 3213 | Clear = 83, |
| 3214 | StartGroup = 84, |
| 3215 | StartGroupCollapsed = 85, |
| 3216 | EndGroup = 86, |
| 3217 | Assert = 87, |
| 3218 | Timing = 88, |
| 3219 | Profile = 89, |
| 3220 | ProfileEnd = 90, |
| 3221 | Image = 91, |
| 3222 | }; // enum class Type |
| 3223 | |
| 3224 | enum { |
| 3225 | NoFieldsSet = 0, |
| 3226 | SourceSet = 1 << 0, |
| 3227 | LevelSet = 1 << 1, |
| 3228 | TextSet = 1 << 2, |
| 3229 | AllFieldsSet = (SourceSet | LevelSet | TextSet) |
| 3230 | }; |
| 3231 | |
| 3232 | template<int STATE> |
| 3233 | class Builder { |
| 3234 | private: |
| 3235 | RefPtr<JSON::Object> m_result; |
| 3236 | |
| 3237 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3238 | { |
| 3239 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3240 | } |
| 3241 | |
| 3242 | Builder(Ref</*ConsoleMessage*/JSON::Object>&& object) |
| 3243 | : m_result(WTFMove(object)) |
| 3244 | { |
| 3245 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3246 | } |
| 3247 | friend class ConsoleMessage; |
| 3248 | public: |
| 3249 | |
| 3250 | Builder<STATE | SourceSet>& setSource(Protocol::Console::ChannelSource in_source) |
| 3251 | { |
| 3252 | COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set); |
| 3253 | m_result->setString("source"_s , Protocol::Helpers::getEnumConstantValue(in_source)); |
| 3254 | return castState<SourceSet>(); |
| 3255 | } |
| 3256 | |
| 3257 | Builder<STATE | LevelSet>& setLevel(Level in_level) |
| 3258 | { |
| 3259 | COMPILE_ASSERT(!(STATE & LevelSet), property_level_already_set); |
| 3260 | m_result->setString("level"_s , Protocol::Helpers::getEnumConstantValue(in_level)); |
| 3261 | return castState<LevelSet>(); |
| 3262 | } |
| 3263 | |
| 3264 | Builder<STATE | TextSet>& setText(const String& in_text) |
| 3265 | { |
| 3266 | COMPILE_ASSERT(!(STATE & TextSet), property_text_already_set); |
| 3267 | m_result->setString("text"_s , in_text); |
| 3268 | return castState<TextSet>(); |
| 3269 | } |
| 3270 | |
| 3271 | Ref<ConsoleMessage> release() |
| 3272 | { |
| 3273 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3274 | COMPILE_ASSERT(sizeof(ConsoleMessage) == sizeof(JSON::Object), cannot_cast); |
| 3275 | |
| 3276 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3277 | auto result = WTFMove(*reinterpret_cast<Ref<ConsoleMessage>*>(&jsonResult)); |
| 3278 | return result; |
| 3279 | } |
| 3280 | }; |
| 3281 | |
| 3282 | /* |
| 3283 | * Synthetic constructor: |
| 3284 | * Ref<ConsoleMessage> result = ConsoleMessage::create() |
| 3285 | * .setSource(...) |
| 3286 | * .setLevel(...) |
| 3287 | * .setText(...) |
| 3288 | * .release(); |
| 3289 | */ |
| 3290 | static Builder<NoFieldsSet> create() |
| 3291 | { |
| 3292 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3293 | } |
| 3294 | |
| 3295 | void setType(Type in_opt_type) |
| 3296 | { |
| 3297 | JSON::ObjectBase::setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_opt_type)); |
| 3298 | } |
| 3299 | |
| 3300 | void setUrl(const String& in_opt_url) |
| 3301 | { |
| 3302 | JSON::ObjectBase::setString("url"_s , in_opt_url); |
| 3303 | } |
| 3304 | |
| 3305 | void setLine(int in_opt_line) |
| 3306 | { |
| 3307 | JSON::ObjectBase::setInteger("line"_s , in_opt_line); |
| 3308 | } |
| 3309 | |
| 3310 | void setColumn(int in_opt_column) |
| 3311 | { |
| 3312 | JSON::ObjectBase::setInteger("column"_s , in_opt_column); |
| 3313 | } |
| 3314 | |
| 3315 | void setRepeatCount(int in_opt_repeatCount) |
| 3316 | { |
| 3317 | JSON::ObjectBase::setInteger("repeatCount"_s , in_opt_repeatCount); |
| 3318 | } |
| 3319 | |
| 3320 | void setParameters(Ref<JSON::ArrayOf<Protocol::Runtime::RemoteObject>>&& in_opt_parameters) |
| 3321 | { |
| 3322 | JSON::ObjectBase::setArray("parameters"_s , WTFMove(in_opt_parameters)); |
| 3323 | } |
| 3324 | |
| 3325 | void setStackTrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_stackTrace) |
| 3326 | { |
| 3327 | JSON::ObjectBase::setArray("stackTrace"_s , WTFMove(in_opt_stackTrace)); |
| 3328 | } |
| 3329 | |
| 3330 | void setNetworkRequestId(const String& in_opt_networkRequestId) |
| 3331 | { |
| 3332 | JSON::ObjectBase::setString("networkRequestId"_s , in_opt_networkRequestId); |
| 3333 | } |
| 3334 | }; |
| 3335 | |
| 3336 | /* Stack entry for console errors and assertions. */ |
| 3337 | class CallFrame final : public JSON::ObjectBase { |
| 3338 | public: |
| 3339 | enum { |
| 3340 | NoFieldsSet = 0, |
| 3341 | FunctionNameSet = 1 << 0, |
| 3342 | UrlSet = 1 << 1, |
| 3343 | ScriptIdSet = 1 << 2, |
| 3344 | LineNumberSet = 1 << 3, |
| 3345 | ColumnNumberSet = 1 << 4, |
| 3346 | AllFieldsSet = (FunctionNameSet | UrlSet | ScriptIdSet | LineNumberSet | ColumnNumberSet) |
| 3347 | }; |
| 3348 | |
| 3349 | template<int STATE> |
| 3350 | class Builder { |
| 3351 | private: |
| 3352 | RefPtr<JSON::Object> m_result; |
| 3353 | |
| 3354 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3355 | { |
| 3356 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3357 | } |
| 3358 | |
| 3359 | Builder(Ref</*CallFrame*/JSON::Object>&& object) |
| 3360 | : m_result(WTFMove(object)) |
| 3361 | { |
| 3362 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3363 | } |
| 3364 | friend class CallFrame; |
| 3365 | public: |
| 3366 | |
| 3367 | Builder<STATE | FunctionNameSet>& setFunctionName(const String& in_functionName) |
| 3368 | { |
| 3369 | COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set); |
| 3370 | m_result->setString("functionName"_s , in_functionName); |
| 3371 | return castState<FunctionNameSet>(); |
| 3372 | } |
| 3373 | |
| 3374 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 3375 | { |
| 3376 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 3377 | m_result->setString("url"_s , in_url); |
| 3378 | return castState<UrlSet>(); |
| 3379 | } |
| 3380 | |
| 3381 | Builder<STATE | ScriptIdSet>& setScriptId(const String& in_scriptId) |
| 3382 | { |
| 3383 | COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set); |
| 3384 | m_result->setString("scriptId"_s , in_scriptId); |
| 3385 | return castState<ScriptIdSet>(); |
| 3386 | } |
| 3387 | |
| 3388 | Builder<STATE | LineNumberSet>& setLineNumber(int in_lineNumber) |
| 3389 | { |
| 3390 | COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set); |
| 3391 | m_result->setInteger("lineNumber"_s , in_lineNumber); |
| 3392 | return castState<LineNumberSet>(); |
| 3393 | } |
| 3394 | |
| 3395 | Builder<STATE | ColumnNumberSet>& setColumnNumber(int in_columnNumber) |
| 3396 | { |
| 3397 | COMPILE_ASSERT(!(STATE & ColumnNumberSet), property_columnNumber_already_set); |
| 3398 | m_result->setInteger("columnNumber"_s , in_columnNumber); |
| 3399 | return castState<ColumnNumberSet>(); |
| 3400 | } |
| 3401 | |
| 3402 | Ref<CallFrame> release() |
| 3403 | { |
| 3404 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3405 | COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast); |
| 3406 | |
| 3407 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3408 | auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult)); |
| 3409 | return result; |
| 3410 | } |
| 3411 | }; |
| 3412 | |
| 3413 | /* |
| 3414 | * Synthetic constructor: |
| 3415 | * Ref<CallFrame> result = CallFrame::create() |
| 3416 | * .setFunctionName(...) |
| 3417 | * .setUrl(...) |
| 3418 | * .setScriptId(...) |
| 3419 | * .setLineNumber(...) |
| 3420 | * .setColumnNumber(...) |
| 3421 | * .release(); |
| 3422 | */ |
| 3423 | static Builder<NoFieldsSet> create() |
| 3424 | { |
| 3425 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3426 | } |
| 3427 | }; |
| 3428 | |
| 3429 | /* Call frames for async function calls, console assertions, and error messages. */ |
| 3430 | class StackTrace final : public JSON::ObjectBase { |
| 3431 | public: |
| 3432 | enum { |
| 3433 | NoFieldsSet = 0, |
| 3434 | CallFramesSet = 1 << 0, |
| 3435 | AllFieldsSet = (CallFramesSet) |
| 3436 | }; |
| 3437 | |
| 3438 | template<int STATE> |
| 3439 | class Builder { |
| 3440 | private: |
| 3441 | RefPtr<JSON::Object> m_result; |
| 3442 | |
| 3443 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3444 | { |
| 3445 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3446 | } |
| 3447 | |
| 3448 | Builder(Ref</*StackTrace*/JSON::Object>&& object) |
| 3449 | : m_result(WTFMove(object)) |
| 3450 | { |
| 3451 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3452 | } |
| 3453 | friend class StackTrace; |
| 3454 | public: |
| 3455 | |
| 3456 | Builder<STATE | CallFramesSet>& setCallFrames(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_callFrames) |
| 3457 | { |
| 3458 | COMPILE_ASSERT(!(STATE & CallFramesSet), property_callFrames_already_set); |
| 3459 | m_result->setArray("callFrames"_s , WTFMove(in_callFrames)); |
| 3460 | return castState<CallFramesSet>(); |
| 3461 | } |
| 3462 | |
| 3463 | Ref<StackTrace> release() |
| 3464 | { |
| 3465 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3466 | COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast); |
| 3467 | |
| 3468 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3469 | auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult)); |
| 3470 | return result; |
| 3471 | } |
| 3472 | }; |
| 3473 | |
| 3474 | /* |
| 3475 | * Synthetic constructor: |
| 3476 | * Ref<StackTrace> result = StackTrace::create() |
| 3477 | * .setCallFrames(...) |
| 3478 | * .release(); |
| 3479 | */ |
| 3480 | static Builder<NoFieldsSet> create() |
| 3481 | { |
| 3482 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3483 | } |
| 3484 | |
| 3485 | void setTopCallFrameIsBoundary(bool in_opt_topCallFrameIsBoundary) |
| 3486 | { |
| 3487 | JSON::ObjectBase::setBoolean("topCallFrameIsBoundary"_s , in_opt_topCallFrameIsBoundary); |
| 3488 | } |
| 3489 | |
| 3490 | void setTruncated(bool in_opt_truncated) |
| 3491 | { |
| 3492 | JSON::ObjectBase::setBoolean("truncated"_s , in_opt_truncated); |
| 3493 | } |
| 3494 | |
| 3495 | void setParentStackTrace(Ref<Protocol::Console::StackTrace>&& in_opt_parentStackTrace) |
| 3496 | { |
| 3497 | JSON::ObjectBase::setObject("parentStackTrace"_s , WTFMove(in_opt_parentStackTrace)); |
| 3498 | } |
| 3499 | }; |
| 3500 | |
| 3501 | } // Console |
| 3502 | |
| 3503 | namespace DOM { |
| 3504 | |
| 3505 | /* Pseudo element type. */ |
| 3506 | enum class PseudoType { |
| 3507 | Before = 24, |
| 3508 | After = 25, |
| 3509 | }; // enum class PseudoType |
| 3510 | |
| 3511 | /* Shadow root type. */ |
| 3512 | enum class ShadowRootType { |
| 3513 | UserAgent = 17, |
| 3514 | Open = 92, |
| 3515 | Closed = 93, |
| 3516 | }; // enum class ShadowRootType |
| 3517 | |
| 3518 | /* Custom element state. */ |
| 3519 | enum class CustomElementState { |
| 3520 | Builtin = 94, |
| 3521 | Custom = 95, |
| 3522 | Waiting = 96, |
| 3523 | Failed = 97, |
| 3524 | }; // enum class CustomElementState |
| 3525 | |
| 3526 | /* Token values of @aria-relevant attribute. */ |
| 3527 | enum class LiveRegionRelevant { |
| 3528 | Additions = 98, |
| 3529 | Removals = 99, |
| 3530 | Text = 100, |
| 3531 | }; // enum class LiveRegionRelevant |
| 3532 | |
| 3533 | /* DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type. */ |
| 3534 | class Node final : public JSON::ObjectBase { |
| 3535 | public: |
| 3536 | enum { |
| 3537 | NoFieldsSet = 0, |
| 3538 | NodeIdSet = 1 << 0, |
| 3539 | NodeTypeSet = 1 << 1, |
| 3540 | NodeNameSet = 1 << 2, |
| 3541 | LocalNameSet = 1 << 3, |
| 3542 | NodeValueSet = 1 << 4, |
| 3543 | AllFieldsSet = (NodeIdSet | NodeTypeSet | NodeNameSet | LocalNameSet | NodeValueSet) |
| 3544 | }; |
| 3545 | |
| 3546 | template<int STATE> |
| 3547 | class Builder { |
| 3548 | private: |
| 3549 | RefPtr<JSON::Object> m_result; |
| 3550 | |
| 3551 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3552 | { |
| 3553 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3554 | } |
| 3555 | |
| 3556 | Builder(Ref</*Node*/JSON::Object>&& object) |
| 3557 | : m_result(WTFMove(object)) |
| 3558 | { |
| 3559 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3560 | } |
| 3561 | friend class Node; |
| 3562 | public: |
| 3563 | |
| 3564 | Builder<STATE | NodeIdSet>& setNodeId(int in_nodeId) |
| 3565 | { |
| 3566 | COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set); |
| 3567 | m_result->setInteger("nodeId"_s , in_nodeId); |
| 3568 | return castState<NodeIdSet>(); |
| 3569 | } |
| 3570 | |
| 3571 | Builder<STATE | NodeTypeSet>& setNodeType(int in_nodeType) |
| 3572 | { |
| 3573 | COMPILE_ASSERT(!(STATE & NodeTypeSet), property_nodeType_already_set); |
| 3574 | m_result->setInteger("nodeType"_s , in_nodeType); |
| 3575 | return castState<NodeTypeSet>(); |
| 3576 | } |
| 3577 | |
| 3578 | Builder<STATE | NodeNameSet>& setNodeName(const String& in_nodeName) |
| 3579 | { |
| 3580 | COMPILE_ASSERT(!(STATE & NodeNameSet), property_nodeName_already_set); |
| 3581 | m_result->setString("nodeName"_s , in_nodeName); |
| 3582 | return castState<NodeNameSet>(); |
| 3583 | } |
| 3584 | |
| 3585 | Builder<STATE | LocalNameSet>& setLocalName(const String& in_localName) |
| 3586 | { |
| 3587 | COMPILE_ASSERT(!(STATE & LocalNameSet), property_localName_already_set); |
| 3588 | m_result->setString("localName"_s , in_localName); |
| 3589 | return castState<LocalNameSet>(); |
| 3590 | } |
| 3591 | |
| 3592 | Builder<STATE | NodeValueSet>& setNodeValue(const String& in_nodeValue) |
| 3593 | { |
| 3594 | COMPILE_ASSERT(!(STATE & NodeValueSet), property_nodeValue_already_set); |
| 3595 | m_result->setString("nodeValue"_s , in_nodeValue); |
| 3596 | return castState<NodeValueSet>(); |
| 3597 | } |
| 3598 | |
| 3599 | Ref<Node> release() |
| 3600 | { |
| 3601 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3602 | COMPILE_ASSERT(sizeof(Node) == sizeof(JSON::Object), cannot_cast); |
| 3603 | |
| 3604 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3605 | auto result = WTFMove(*reinterpret_cast<Ref<Node>*>(&jsonResult)); |
| 3606 | return result; |
| 3607 | } |
| 3608 | }; |
| 3609 | |
| 3610 | /* |
| 3611 | * Synthetic constructor: |
| 3612 | * Ref<Node> result = Node::create() |
| 3613 | * .setNodeId(...) |
| 3614 | * .setNodeType(...) |
| 3615 | * .setNodeName(...) |
| 3616 | * .setLocalName(...) |
| 3617 | * .setNodeValue(...) |
| 3618 | * .release(); |
| 3619 | */ |
| 3620 | static Builder<NoFieldsSet> create() |
| 3621 | { |
| 3622 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3623 | } |
| 3624 | |
| 3625 | void setFrameId(const String& in_opt_frameId) |
| 3626 | { |
| 3627 | JSON::ObjectBase::setString("frameId"_s , in_opt_frameId); |
| 3628 | } |
| 3629 | |
| 3630 | void setChildNodeCount(int in_opt_childNodeCount) |
| 3631 | { |
| 3632 | JSON::ObjectBase::setInteger("childNodeCount"_s , in_opt_childNodeCount); |
| 3633 | } |
| 3634 | |
| 3635 | void setChildren(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_children) |
| 3636 | { |
| 3637 | JSON::ObjectBase::setArray("children"_s , WTFMove(in_opt_children)); |
| 3638 | } |
| 3639 | |
| 3640 | void setAttributes(Ref<JSON::ArrayOf<String>>&& in_opt_attributes) |
| 3641 | { |
| 3642 | JSON::ObjectBase::setArray("attributes"_s , WTFMove(in_opt_attributes)); |
| 3643 | } |
| 3644 | |
| 3645 | void setDocumentURL(const String& in_opt_documentURL) |
| 3646 | { |
| 3647 | JSON::ObjectBase::setString("documentURL"_s , in_opt_documentURL); |
| 3648 | } |
| 3649 | |
| 3650 | void setBaseURL(const String& in_opt_baseURL) |
| 3651 | { |
| 3652 | JSON::ObjectBase::setString("baseURL"_s , in_opt_baseURL); |
| 3653 | } |
| 3654 | |
| 3655 | void setPublicId(const String& in_opt_publicId) |
| 3656 | { |
| 3657 | JSON::ObjectBase::setString("publicId"_s , in_opt_publicId); |
| 3658 | } |
| 3659 | |
| 3660 | void setSystemId(const String& in_opt_systemId) |
| 3661 | { |
| 3662 | JSON::ObjectBase::setString("systemId"_s , in_opt_systemId); |
| 3663 | } |
| 3664 | |
| 3665 | void setXmlVersion(const String& in_opt_xmlVersion) |
| 3666 | { |
| 3667 | JSON::ObjectBase::setString("xmlVersion"_s , in_opt_xmlVersion); |
| 3668 | } |
| 3669 | |
| 3670 | void setName(const String& in_opt_name) |
| 3671 | { |
| 3672 | JSON::ObjectBase::setString("name"_s , in_opt_name); |
| 3673 | } |
| 3674 | |
| 3675 | void setValue(const String& in_opt_value) |
| 3676 | { |
| 3677 | JSON::ObjectBase::setString("value"_s , in_opt_value); |
| 3678 | } |
| 3679 | |
| 3680 | void setPseudoType(Protocol::DOM::PseudoType in_opt_pseudoType) |
| 3681 | { |
| 3682 | JSON::ObjectBase::setString("pseudoType"_s , Protocol::Helpers::getEnumConstantValue(in_opt_pseudoType)); |
| 3683 | } |
| 3684 | |
| 3685 | void setShadowRootType(Protocol::DOM::ShadowRootType in_opt_shadowRootType) |
| 3686 | { |
| 3687 | JSON::ObjectBase::setString("shadowRootType"_s , Protocol::Helpers::getEnumConstantValue(in_opt_shadowRootType)); |
| 3688 | } |
| 3689 | |
| 3690 | void setCustomElementState(Protocol::DOM::CustomElementState in_opt_customElementState) |
| 3691 | { |
| 3692 | JSON::ObjectBase::setString("customElementState"_s , Protocol::Helpers::getEnumConstantValue(in_opt_customElementState)); |
| 3693 | } |
| 3694 | |
| 3695 | void setContentDocument(Ref<Protocol::DOM::Node>&& in_opt_contentDocument) |
| 3696 | { |
| 3697 | JSON::ObjectBase::setObject("contentDocument"_s , WTFMove(in_opt_contentDocument)); |
| 3698 | } |
| 3699 | |
| 3700 | void setShadowRoots(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_shadowRoots) |
| 3701 | { |
| 3702 | JSON::ObjectBase::setArray("shadowRoots"_s , WTFMove(in_opt_shadowRoots)); |
| 3703 | } |
| 3704 | |
| 3705 | void setTemplateContent(Ref<Protocol::DOM::Node>&& in_opt_templateContent) |
| 3706 | { |
| 3707 | JSON::ObjectBase::setObject("templateContent"_s , WTFMove(in_opt_templateContent)); |
| 3708 | } |
| 3709 | |
| 3710 | void setPseudoElements(Ref<JSON::ArrayOf<Protocol::DOM::Node>>&& in_opt_pseudoElements) |
| 3711 | { |
| 3712 | JSON::ObjectBase::setArray("pseudoElements"_s , WTFMove(in_opt_pseudoElements)); |
| 3713 | } |
| 3714 | |
| 3715 | void setContentSecurityPolicyHash(const String& in_opt_contentSecurityPolicyHash) |
| 3716 | { |
| 3717 | JSON::ObjectBase::setString("contentSecurityPolicyHash"_s , in_opt_contentSecurityPolicyHash); |
| 3718 | } |
| 3719 | |
| 3720 | void setLayoutContextType(Protocol::CSS::LayoutContextType in_opt_layoutContextType) |
| 3721 | { |
| 3722 | JSON::ObjectBase::setString("layoutContextType"_s , Protocol::Helpers::getEnumConstantValue(in_opt_layoutContextType)); |
| 3723 | } |
| 3724 | }; |
| 3725 | |
| 3726 | /* Relationship between data that is associated with a node and the node itself. */ |
| 3727 | class DataBinding final : public JSON::ObjectBase { |
| 3728 | public: |
| 3729 | enum { |
| 3730 | NoFieldsSet = 0, |
| 3731 | BindingSet = 1 << 0, |
| 3732 | ValueSet = 1 << 1, |
| 3733 | AllFieldsSet = (BindingSet | ValueSet) |
| 3734 | }; |
| 3735 | |
| 3736 | template<int STATE> |
| 3737 | class Builder { |
| 3738 | private: |
| 3739 | RefPtr<JSON::Object> m_result; |
| 3740 | |
| 3741 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3742 | { |
| 3743 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3744 | } |
| 3745 | |
| 3746 | Builder(Ref</*DataBinding*/JSON::Object>&& object) |
| 3747 | : m_result(WTFMove(object)) |
| 3748 | { |
| 3749 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3750 | } |
| 3751 | friend class DataBinding; |
| 3752 | public: |
| 3753 | |
| 3754 | Builder<STATE | BindingSet>& setBinding(const String& in_binding) |
| 3755 | { |
| 3756 | COMPILE_ASSERT(!(STATE & BindingSet), property_binding_already_set); |
| 3757 | m_result->setString("binding"_s , in_binding); |
| 3758 | return castState<BindingSet>(); |
| 3759 | } |
| 3760 | |
| 3761 | Builder<STATE | ValueSet>& setValue(const String& in_value) |
| 3762 | { |
| 3763 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 3764 | m_result->setString("value"_s , in_value); |
| 3765 | return castState<ValueSet>(); |
| 3766 | } |
| 3767 | |
| 3768 | Ref<DataBinding> release() |
| 3769 | { |
| 3770 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3771 | COMPILE_ASSERT(sizeof(DataBinding) == sizeof(JSON::Object), cannot_cast); |
| 3772 | |
| 3773 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3774 | auto result = WTFMove(*reinterpret_cast<Ref<DataBinding>*>(&jsonResult)); |
| 3775 | return result; |
| 3776 | } |
| 3777 | }; |
| 3778 | |
| 3779 | /* |
| 3780 | * Synthetic constructor: |
| 3781 | * Ref<DataBinding> result = DataBinding::create() |
| 3782 | * .setBinding(...) |
| 3783 | * .setValue(...) |
| 3784 | * .release(); |
| 3785 | */ |
| 3786 | static Builder<NoFieldsSet> create() |
| 3787 | { |
| 3788 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3789 | } |
| 3790 | |
| 3791 | void setType(const String& in_opt_type) |
| 3792 | { |
| 3793 | JSON::ObjectBase::setString("type"_s , in_opt_type); |
| 3794 | } |
| 3795 | }; |
| 3796 | |
| 3797 | /* A structure holding event listener properties. */ |
| 3798 | class EventListener final : public JSON::ObjectBase { |
| 3799 | public: |
| 3800 | enum { |
| 3801 | NoFieldsSet = 0, |
| 3802 | EventListenerIdSet = 1 << 0, |
| 3803 | TypeSet = 1 << 1, |
| 3804 | UseCaptureSet = 1 << 2, |
| 3805 | IsAttributeSet = 1 << 3, |
| 3806 | AllFieldsSet = (EventListenerIdSet | TypeSet | UseCaptureSet | IsAttributeSet) |
| 3807 | }; |
| 3808 | |
| 3809 | template<int STATE> |
| 3810 | class Builder { |
| 3811 | private: |
| 3812 | RefPtr<JSON::Object> m_result; |
| 3813 | |
| 3814 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3815 | { |
| 3816 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3817 | } |
| 3818 | |
| 3819 | Builder(Ref</*EventListener*/JSON::Object>&& object) |
| 3820 | : m_result(WTFMove(object)) |
| 3821 | { |
| 3822 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3823 | } |
| 3824 | friend class EventListener; |
| 3825 | public: |
| 3826 | |
| 3827 | Builder<STATE | EventListenerIdSet>& setEventListenerId(int in_eventListenerId) |
| 3828 | { |
| 3829 | COMPILE_ASSERT(!(STATE & EventListenerIdSet), property_eventListenerId_already_set); |
| 3830 | m_result->setInteger("eventListenerId"_s , in_eventListenerId); |
| 3831 | return castState<EventListenerIdSet>(); |
| 3832 | } |
| 3833 | |
| 3834 | Builder<STATE | TypeSet>& setType(const String& in_type) |
| 3835 | { |
| 3836 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 3837 | m_result->setString("type"_s , in_type); |
| 3838 | return castState<TypeSet>(); |
| 3839 | } |
| 3840 | |
| 3841 | Builder<STATE | UseCaptureSet>& setUseCapture(bool in_useCapture) |
| 3842 | { |
| 3843 | COMPILE_ASSERT(!(STATE & UseCaptureSet), property_useCapture_already_set); |
| 3844 | m_result->setBoolean("useCapture"_s , in_useCapture); |
| 3845 | return castState<UseCaptureSet>(); |
| 3846 | } |
| 3847 | |
| 3848 | Builder<STATE | IsAttributeSet>& setIsAttribute(bool in_isAttribute) |
| 3849 | { |
| 3850 | COMPILE_ASSERT(!(STATE & IsAttributeSet), property_isAttribute_already_set); |
| 3851 | m_result->setBoolean("isAttribute"_s , in_isAttribute); |
| 3852 | return castState<IsAttributeSet>(); |
| 3853 | } |
| 3854 | |
| 3855 | Ref<EventListener> release() |
| 3856 | { |
| 3857 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 3858 | COMPILE_ASSERT(sizeof(EventListener) == sizeof(JSON::Object), cannot_cast); |
| 3859 | |
| 3860 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 3861 | auto result = WTFMove(*reinterpret_cast<Ref<EventListener>*>(&jsonResult)); |
| 3862 | return result; |
| 3863 | } |
| 3864 | }; |
| 3865 | |
| 3866 | /* |
| 3867 | * Synthetic constructor: |
| 3868 | * Ref<EventListener> result = EventListener::create() |
| 3869 | * .setEventListenerId(...) |
| 3870 | * .setType(...) |
| 3871 | * .setUseCapture(...) |
| 3872 | * .setIsAttribute(...) |
| 3873 | * .release(); |
| 3874 | */ |
| 3875 | static Builder<NoFieldsSet> create() |
| 3876 | { |
| 3877 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 3878 | } |
| 3879 | |
| 3880 | void setNodeId(int in_opt_nodeId) |
| 3881 | { |
| 3882 | JSON::ObjectBase::setInteger("nodeId"_s , in_opt_nodeId); |
| 3883 | } |
| 3884 | |
| 3885 | void setOnWindow(bool in_opt_onWindow) |
| 3886 | { |
| 3887 | JSON::ObjectBase::setBoolean("onWindow"_s , in_opt_onWindow); |
| 3888 | } |
| 3889 | |
| 3890 | void setLocation(Ref<Protocol::Debugger::Location>&& in_opt_location) |
| 3891 | { |
| 3892 | JSON::ObjectBase::setObject("location"_s , WTFMove(in_opt_location)); |
| 3893 | } |
| 3894 | |
| 3895 | void setHandlerName(const String& in_opt_handlerName) |
| 3896 | { |
| 3897 | JSON::ObjectBase::setString("handlerName"_s , in_opt_handlerName); |
| 3898 | } |
| 3899 | |
| 3900 | void setPassive(bool in_opt_passive) |
| 3901 | { |
| 3902 | JSON::ObjectBase::setBoolean("passive"_s , in_opt_passive); |
| 3903 | } |
| 3904 | |
| 3905 | void setOnce(bool in_opt_once) |
| 3906 | { |
| 3907 | JSON::ObjectBase::setBoolean("once"_s , in_opt_once); |
| 3908 | } |
| 3909 | |
| 3910 | void setDisabled(bool in_opt_disabled) |
| 3911 | { |
| 3912 | JSON::ObjectBase::setBoolean("disabled"_s , in_opt_disabled); |
| 3913 | } |
| 3914 | |
| 3915 | void setHasBreakpoint(bool in_opt_hasBreakpoint) |
| 3916 | { |
| 3917 | JSON::ObjectBase::setBoolean("hasBreakpoint"_s , in_opt_hasBreakpoint); |
| 3918 | } |
| 3919 | }; |
| 3920 | |
| 3921 | /* A structure holding accessibility properties. */ |
| 3922 | class AccessibilityProperties final : public JSON::ObjectBase { |
| 3923 | public: |
| 3924 | // Named after property name 'checked' while generating AccessibilityProperties. |
| 3925 | enum class Checked { |
| 3926 | True = 101, |
| 3927 | False = 102, |
| 3928 | Mixed = 103, |
| 3929 | }; // enum class Checked |
| 3930 | |
| 3931 | // Named after property name 'current' while generating AccessibilityProperties. |
| 3932 | enum class Current { |
| 3933 | True = 101, |
| 3934 | False = 102, |
| 3935 | Page = 104, |
| 3936 | Step = 105, |
| 3937 | Location = 106, |
| 3938 | Date = 107, |
| 3939 | Time = 108, |
| 3940 | }; // enum class Current |
| 3941 | |
| 3942 | // Named after property name 'invalid' while generating AccessibilityProperties. |
| 3943 | enum class Invalid { |
| 3944 | True = 101, |
| 3945 | False = 102, |
| 3946 | Grammar = 109, |
| 3947 | Spelling = 110, |
| 3948 | }; // enum class Invalid |
| 3949 | |
| 3950 | // Named after property name 'liveRegionStatus' while generating AccessibilityProperties. |
| 3951 | enum class LiveRegionStatus { |
| 3952 | Assertive = 111, |
| 3953 | Polite = 112, |
| 3954 | Off = 71, |
| 3955 | }; // enum class LiveRegionStatus |
| 3956 | |
| 3957 | enum { |
| 3958 | NoFieldsSet = 0, |
| 3959 | ExistsSet = 1 << 0, |
| 3960 | LabelSet = 1 << 1, |
| 3961 | NodeIdSet = 1 << 2, |
| 3962 | RoleSet = 1 << 3, |
| 3963 | AllFieldsSet = (ExistsSet | LabelSet | NodeIdSet | RoleSet) |
| 3964 | }; |
| 3965 | |
| 3966 | template<int STATE> |
| 3967 | class Builder { |
| 3968 | private: |
| 3969 | RefPtr<JSON::Object> m_result; |
| 3970 | |
| 3971 | template<int STEP> Builder<STATE | STEP>& castState() |
| 3972 | { |
| 3973 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 3974 | } |
| 3975 | |
| 3976 | Builder(Ref</*AccessibilityProperties*/JSON::Object>&& object) |
| 3977 | : m_result(WTFMove(object)) |
| 3978 | { |
| 3979 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 3980 | } |
| 3981 | friend class AccessibilityProperties; |
| 3982 | public: |
| 3983 | |
| 3984 | Builder<STATE | ExistsSet>& setExists(bool in_exists) |
| 3985 | { |
| 3986 | COMPILE_ASSERT(!(STATE & ExistsSet), property_exists_already_set); |
| 3987 | m_result->setBoolean("exists"_s , in_exists); |
| 3988 | return castState<ExistsSet>(); |
| 3989 | } |
| 3990 | |
| 3991 | Builder<STATE | LabelSet>& setLabel(const String& in_label) |
| 3992 | { |
| 3993 | COMPILE_ASSERT(!(STATE & LabelSet), property_label_already_set); |
| 3994 | m_result->setString("label"_s , in_label); |
| 3995 | return castState<LabelSet>(); |
| 3996 | } |
| 3997 | |
| 3998 | Builder<STATE | NodeIdSet>& setNodeId(int in_nodeId) |
| 3999 | { |
| 4000 | COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set); |
| 4001 | m_result->setInteger("nodeId"_s , in_nodeId); |
| 4002 | return castState<NodeIdSet>(); |
| 4003 | } |
| 4004 | |
| 4005 | Builder<STATE | RoleSet>& setRole(const String& in_role) |
| 4006 | { |
| 4007 | COMPILE_ASSERT(!(STATE & RoleSet), property_role_already_set); |
| 4008 | m_result->setString("role"_s , in_role); |
| 4009 | return castState<RoleSet>(); |
| 4010 | } |
| 4011 | |
| 4012 | Ref<AccessibilityProperties> release() |
| 4013 | { |
| 4014 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4015 | COMPILE_ASSERT(sizeof(AccessibilityProperties) == sizeof(JSON::Object), cannot_cast); |
| 4016 | |
| 4017 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4018 | auto result = WTFMove(*reinterpret_cast<Ref<AccessibilityProperties>*>(&jsonResult)); |
| 4019 | return result; |
| 4020 | } |
| 4021 | }; |
| 4022 | |
| 4023 | /* |
| 4024 | * Synthetic constructor: |
| 4025 | * Ref<AccessibilityProperties> result = AccessibilityProperties::create() |
| 4026 | * .setExists(...) |
| 4027 | * .setLabel(...) |
| 4028 | * .setNodeId(...) |
| 4029 | * .setRole(...) |
| 4030 | * .release(); |
| 4031 | */ |
| 4032 | static Builder<NoFieldsSet> create() |
| 4033 | { |
| 4034 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4035 | } |
| 4036 | |
| 4037 | void setActiveDescendantNodeId(int in_opt_activeDescendantNodeId) |
| 4038 | { |
| 4039 | JSON::ObjectBase::setInteger("activeDescendantNodeId"_s , in_opt_activeDescendantNodeId); |
| 4040 | } |
| 4041 | |
| 4042 | void setBusy(bool in_opt_busy) |
| 4043 | { |
| 4044 | JSON::ObjectBase::setBoolean("busy"_s , in_opt_busy); |
| 4045 | } |
| 4046 | |
| 4047 | void setChecked(Checked in_opt_checked) |
| 4048 | { |
| 4049 | JSON::ObjectBase::setString("checked"_s , Protocol::Helpers::getEnumConstantValue(in_opt_checked)); |
| 4050 | } |
| 4051 | |
| 4052 | void setChildNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_childNodeIds) |
| 4053 | { |
| 4054 | JSON::ObjectBase::setArray("childNodeIds"_s , WTFMove(in_opt_childNodeIds)); |
| 4055 | } |
| 4056 | |
| 4057 | void setControlledNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_controlledNodeIds) |
| 4058 | { |
| 4059 | JSON::ObjectBase::setArray("controlledNodeIds"_s , WTFMove(in_opt_controlledNodeIds)); |
| 4060 | } |
| 4061 | |
| 4062 | void setCurrent(Current in_opt_current) |
| 4063 | { |
| 4064 | JSON::ObjectBase::setString("current"_s , Protocol::Helpers::getEnumConstantValue(in_opt_current)); |
| 4065 | } |
| 4066 | |
| 4067 | void setDisabled(bool in_opt_disabled) |
| 4068 | { |
| 4069 | JSON::ObjectBase::setBoolean("disabled"_s , in_opt_disabled); |
| 4070 | } |
| 4071 | |
| 4072 | void setHeadingLevel(double in_opt_headingLevel) |
| 4073 | { |
| 4074 | JSON::ObjectBase::setDouble("headingLevel"_s , in_opt_headingLevel); |
| 4075 | } |
| 4076 | |
| 4077 | void setHierarchyLevel(double in_opt_hierarchyLevel) |
| 4078 | { |
| 4079 | JSON::ObjectBase::setDouble("hierarchyLevel"_s , in_opt_hierarchyLevel); |
| 4080 | } |
| 4081 | |
| 4082 | void (bool ) |
| 4083 | { |
| 4084 | JSON::ObjectBase::setBoolean("isPopUpButton"_s , in_opt_isPopUpButton); |
| 4085 | } |
| 4086 | |
| 4087 | void setExpanded(bool in_opt_expanded) |
| 4088 | { |
| 4089 | JSON::ObjectBase::setBoolean("expanded"_s , in_opt_expanded); |
| 4090 | } |
| 4091 | |
| 4092 | void setFlowedNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_flowedNodeIds) |
| 4093 | { |
| 4094 | JSON::ObjectBase::setArray("flowedNodeIds"_s , WTFMove(in_opt_flowedNodeIds)); |
| 4095 | } |
| 4096 | |
| 4097 | void setFocused(bool in_opt_focused) |
| 4098 | { |
| 4099 | JSON::ObjectBase::setBoolean("focused"_s , in_opt_focused); |
| 4100 | } |
| 4101 | |
| 4102 | void setIgnored(bool in_opt_ignored) |
| 4103 | { |
| 4104 | JSON::ObjectBase::setBoolean("ignored"_s , in_opt_ignored); |
| 4105 | } |
| 4106 | |
| 4107 | void setIgnoredByDefault(bool in_opt_ignoredByDefault) |
| 4108 | { |
| 4109 | JSON::ObjectBase::setBoolean("ignoredByDefault"_s , in_opt_ignoredByDefault); |
| 4110 | } |
| 4111 | |
| 4112 | void setInvalid(Invalid in_opt_invalid) |
| 4113 | { |
| 4114 | JSON::ObjectBase::setString("invalid"_s , Protocol::Helpers::getEnumConstantValue(in_opt_invalid)); |
| 4115 | } |
| 4116 | |
| 4117 | void setHidden(bool in_opt_hidden) |
| 4118 | { |
| 4119 | JSON::ObjectBase::setBoolean("hidden"_s , in_opt_hidden); |
| 4120 | } |
| 4121 | |
| 4122 | void setLiveRegionAtomic(bool in_opt_liveRegionAtomic) |
| 4123 | { |
| 4124 | JSON::ObjectBase::setBoolean("liveRegionAtomic"_s , in_opt_liveRegionAtomic); |
| 4125 | } |
| 4126 | |
| 4127 | void setLiveRegionRelevant(Ref<JSON::ArrayOf<String>>&& in_opt_liveRegionRelevant) |
| 4128 | { |
| 4129 | JSON::ObjectBase::setArray("liveRegionRelevant"_s , WTFMove(in_opt_liveRegionRelevant)); |
| 4130 | } |
| 4131 | |
| 4132 | void setLiveRegionStatus(LiveRegionStatus in_opt_liveRegionStatus) |
| 4133 | { |
| 4134 | JSON::ObjectBase::setString("liveRegionStatus"_s , Protocol::Helpers::getEnumConstantValue(in_opt_liveRegionStatus)); |
| 4135 | } |
| 4136 | |
| 4137 | void setMouseEventNodeId(int in_opt_mouseEventNodeId) |
| 4138 | { |
| 4139 | JSON::ObjectBase::setInteger("mouseEventNodeId"_s , in_opt_mouseEventNodeId); |
| 4140 | } |
| 4141 | |
| 4142 | void setOwnedNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_ownedNodeIds) |
| 4143 | { |
| 4144 | JSON::ObjectBase::setArray("ownedNodeIds"_s , WTFMove(in_opt_ownedNodeIds)); |
| 4145 | } |
| 4146 | |
| 4147 | void setParentNodeId(int in_opt_parentNodeId) |
| 4148 | { |
| 4149 | JSON::ObjectBase::setInteger("parentNodeId"_s , in_opt_parentNodeId); |
| 4150 | } |
| 4151 | |
| 4152 | void setPressed(bool in_opt_pressed) |
| 4153 | { |
| 4154 | JSON::ObjectBase::setBoolean("pressed"_s , in_opt_pressed); |
| 4155 | } |
| 4156 | |
| 4157 | void setReadonly(bool in_opt_readonly) |
| 4158 | { |
| 4159 | JSON::ObjectBase::setBoolean("readonly"_s , in_opt_readonly); |
| 4160 | } |
| 4161 | |
| 4162 | void setRequired(bool in_opt_required) |
| 4163 | { |
| 4164 | JSON::ObjectBase::setBoolean("required"_s , in_opt_required); |
| 4165 | } |
| 4166 | |
| 4167 | void setSelected(bool in_opt_selected) |
| 4168 | { |
| 4169 | JSON::ObjectBase::setBoolean("selected"_s , in_opt_selected); |
| 4170 | } |
| 4171 | |
| 4172 | void setSelectedChildNodeIds(Ref<JSON::ArrayOf<int>>&& in_opt_selectedChildNodeIds) |
| 4173 | { |
| 4174 | JSON::ObjectBase::setArray("selectedChildNodeIds"_s , WTFMove(in_opt_selectedChildNodeIds)); |
| 4175 | } |
| 4176 | }; |
| 4177 | |
| 4178 | /* A structure holding an RGBA color. */ |
| 4179 | class RGBAColor final : public JSON::Object { |
| 4180 | public: |
| 4181 | enum { |
| 4182 | NoFieldsSet = 0, |
| 4183 | RSet = 1 << 0, |
| 4184 | GSet = 1 << 1, |
| 4185 | BSet = 1 << 2, |
| 4186 | AllFieldsSet = (RSet | GSet | BSet) |
| 4187 | }; |
| 4188 | |
| 4189 | template<int STATE> |
| 4190 | class Builder { |
| 4191 | private: |
| 4192 | RefPtr<JSON::Object> m_result; |
| 4193 | |
| 4194 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4195 | { |
| 4196 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4197 | } |
| 4198 | |
| 4199 | Builder(Ref</*RGBAColor*/JSON::Object>&& object) |
| 4200 | : m_result(WTFMove(object)) |
| 4201 | { |
| 4202 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4203 | } |
| 4204 | friend class RGBAColor; |
| 4205 | public: |
| 4206 | |
| 4207 | Builder<STATE | RSet>& setR(int in_r) |
| 4208 | { |
| 4209 | COMPILE_ASSERT(!(STATE & RSet), property_r_already_set); |
| 4210 | m_result->setInteger("r"_s , in_r); |
| 4211 | return castState<RSet>(); |
| 4212 | } |
| 4213 | |
| 4214 | Builder<STATE | GSet>& setG(int in_g) |
| 4215 | { |
| 4216 | COMPILE_ASSERT(!(STATE & GSet), property_g_already_set); |
| 4217 | m_result->setInteger("g"_s , in_g); |
| 4218 | return castState<GSet>(); |
| 4219 | } |
| 4220 | |
| 4221 | Builder<STATE | BSet>& setB(int in_b) |
| 4222 | { |
| 4223 | COMPILE_ASSERT(!(STATE & BSet), property_b_already_set); |
| 4224 | m_result->setInteger("b"_s , in_b); |
| 4225 | return castState<BSet>(); |
| 4226 | } |
| 4227 | |
| 4228 | Ref<RGBAColor> release() |
| 4229 | { |
| 4230 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4231 | COMPILE_ASSERT(sizeof(RGBAColor) == sizeof(JSON::Object), cannot_cast); |
| 4232 | |
| 4233 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4234 | auto result = WTFMove(*reinterpret_cast<Ref<RGBAColor>*>(&jsonResult)); |
| 4235 | return result; |
| 4236 | } |
| 4237 | }; |
| 4238 | |
| 4239 | /* |
| 4240 | * Synthetic constructor: |
| 4241 | * Ref<RGBAColor> result = RGBAColor::create() |
| 4242 | * .setR(...) |
| 4243 | * .setG(...) |
| 4244 | * .setB(...) |
| 4245 | * .release(); |
| 4246 | */ |
| 4247 | static Builder<NoFieldsSet> create() |
| 4248 | { |
| 4249 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4250 | } |
| 4251 | |
| 4252 | void setA(double in_opt_a) |
| 4253 | { |
| 4254 | JSON::ObjectBase::setDouble("a"_s , in_opt_a); |
| 4255 | } |
| 4256 | |
| 4257 | // Property names for type generated as open. |
| 4258 | JS_EXPORT_PRIVATE static const ASCIILiteral rKey; |
| 4259 | JS_EXPORT_PRIVATE static const ASCIILiteral gKey; |
| 4260 | JS_EXPORT_PRIVATE static const ASCIILiteral bKey; |
| 4261 | JS_EXPORT_PRIVATE static const ASCIILiteral aKey; |
| 4262 | }; |
| 4263 | |
| 4264 | /* Configuration data for the highlighting of page elements. */ |
| 4265 | class HighlightConfig final : public JSON::Object { |
| 4266 | public: |
| 4267 | enum { |
| 4268 | NoFieldsSet = 0, |
| 4269 | AllFieldsSet = 0 |
| 4270 | }; |
| 4271 | |
| 4272 | template<int STATE> |
| 4273 | class Builder { |
| 4274 | private: |
| 4275 | RefPtr<JSON::Object> m_result; |
| 4276 | |
| 4277 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4278 | { |
| 4279 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4280 | } |
| 4281 | |
| 4282 | Builder(Ref</*HighlightConfig*/JSON::Object>&& object) |
| 4283 | : m_result(WTFMove(object)) |
| 4284 | { |
| 4285 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4286 | } |
| 4287 | friend class HighlightConfig; |
| 4288 | public: |
| 4289 | |
| 4290 | Ref<HighlightConfig> release() |
| 4291 | { |
| 4292 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4293 | COMPILE_ASSERT(sizeof(HighlightConfig) == sizeof(JSON::Object), cannot_cast); |
| 4294 | |
| 4295 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4296 | auto result = WTFMove(*reinterpret_cast<Ref<HighlightConfig>*>(&jsonResult)); |
| 4297 | return result; |
| 4298 | } |
| 4299 | }; |
| 4300 | |
| 4301 | /* |
| 4302 | * Synthetic constructor: |
| 4303 | * Ref<HighlightConfig> result = HighlightConfig::create() |
| 4304 | * .release(); |
| 4305 | */ |
| 4306 | static Builder<NoFieldsSet> create() |
| 4307 | { |
| 4308 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4309 | } |
| 4310 | |
| 4311 | void setShowInfo(bool in_opt_showInfo) |
| 4312 | { |
| 4313 | JSON::ObjectBase::setBoolean("showInfo"_s , in_opt_showInfo); |
| 4314 | } |
| 4315 | |
| 4316 | void setContentColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_contentColor) |
| 4317 | { |
| 4318 | JSON::ObjectBase::setObject("contentColor"_s , WTFMove(in_opt_contentColor)); |
| 4319 | } |
| 4320 | |
| 4321 | void setPaddingColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_paddingColor) |
| 4322 | { |
| 4323 | JSON::ObjectBase::setObject("paddingColor"_s , WTFMove(in_opt_paddingColor)); |
| 4324 | } |
| 4325 | |
| 4326 | void setBorderColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_borderColor) |
| 4327 | { |
| 4328 | JSON::ObjectBase::setObject("borderColor"_s , WTFMove(in_opt_borderColor)); |
| 4329 | } |
| 4330 | |
| 4331 | void setMarginColor(Ref<Protocol::DOM::RGBAColor>&& in_opt_marginColor) |
| 4332 | { |
| 4333 | JSON::ObjectBase::setObject("marginColor"_s , WTFMove(in_opt_marginColor)); |
| 4334 | } |
| 4335 | |
| 4336 | // Property names for type generated as open. |
| 4337 | JS_EXPORT_PRIVATE static const ASCIILiteral showInfoKey; |
| 4338 | JS_EXPORT_PRIVATE static const ASCIILiteral contentColorKey; |
| 4339 | JS_EXPORT_PRIVATE static const ASCIILiteral paddingColorKey; |
| 4340 | JS_EXPORT_PRIVATE static const ASCIILiteral borderColorKey; |
| 4341 | JS_EXPORT_PRIVATE static const ASCIILiteral marginColorKey; |
| 4342 | }; |
| 4343 | |
| 4344 | } // DOM |
| 4345 | |
| 4346 | namespace DOMDebugger { |
| 4347 | |
| 4348 | /* DOM breakpoint type. */ |
| 4349 | enum class DOMBreakpointType { |
| 4350 | SubtreeModified = 113, |
| 4351 | AttributeModified = 114, |
| 4352 | NodeRemoved = 115, |
| 4353 | }; // enum class DOMBreakpointType |
| 4354 | |
| 4355 | /* Event breakpoint type. */ |
| 4356 | enum class EventBreakpointType { |
| 4357 | AnimationFrame = 116, |
| 4358 | Interval = 117, |
| 4359 | Listener = 118, |
| 4360 | Timeout = 119, |
| 4361 | }; // enum class EventBreakpointType |
| 4362 | |
| 4363 | } // DOMDebugger |
| 4364 | |
| 4365 | namespace DOMStorage { |
| 4366 | |
| 4367 | /* DOM Storage identifier. */ |
| 4368 | class StorageId final : public JSON::Object { |
| 4369 | public: |
| 4370 | enum { |
| 4371 | NoFieldsSet = 0, |
| 4372 | SecurityOriginSet = 1 << 0, |
| 4373 | IsLocalStorageSet = 1 << 1, |
| 4374 | AllFieldsSet = (SecurityOriginSet | IsLocalStorageSet) |
| 4375 | }; |
| 4376 | |
| 4377 | template<int STATE> |
| 4378 | class Builder { |
| 4379 | private: |
| 4380 | RefPtr<JSON::Object> m_result; |
| 4381 | |
| 4382 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4383 | { |
| 4384 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4385 | } |
| 4386 | |
| 4387 | Builder(Ref</*StorageId*/JSON::Object>&& object) |
| 4388 | : m_result(WTFMove(object)) |
| 4389 | { |
| 4390 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4391 | } |
| 4392 | friend class StorageId; |
| 4393 | public: |
| 4394 | |
| 4395 | Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin) |
| 4396 | { |
| 4397 | COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set); |
| 4398 | m_result->setString("securityOrigin"_s , in_securityOrigin); |
| 4399 | return castState<SecurityOriginSet>(); |
| 4400 | } |
| 4401 | |
| 4402 | Builder<STATE | IsLocalStorageSet>& setIsLocalStorage(bool in_isLocalStorage) |
| 4403 | { |
| 4404 | COMPILE_ASSERT(!(STATE & IsLocalStorageSet), property_isLocalStorage_already_set); |
| 4405 | m_result->setBoolean("isLocalStorage"_s , in_isLocalStorage); |
| 4406 | return castState<IsLocalStorageSet>(); |
| 4407 | } |
| 4408 | |
| 4409 | Ref<StorageId> release() |
| 4410 | { |
| 4411 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4412 | COMPILE_ASSERT(sizeof(StorageId) == sizeof(JSON::Object), cannot_cast); |
| 4413 | |
| 4414 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4415 | auto result = WTFMove(*reinterpret_cast<Ref<StorageId>*>(&jsonResult)); |
| 4416 | return result; |
| 4417 | } |
| 4418 | }; |
| 4419 | |
| 4420 | /* |
| 4421 | * Synthetic constructor: |
| 4422 | * Ref<StorageId> result = StorageId::create() |
| 4423 | * .setSecurityOrigin(...) |
| 4424 | * .setIsLocalStorage(...) |
| 4425 | * .release(); |
| 4426 | */ |
| 4427 | static Builder<NoFieldsSet> create() |
| 4428 | { |
| 4429 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4430 | } |
| 4431 | |
| 4432 | // Property names for type generated as open. |
| 4433 | JS_EXPORT_PRIVATE static const ASCIILiteral securityOriginKey; |
| 4434 | JS_EXPORT_PRIVATE static const ASCIILiteral isLocalStorageKey; |
| 4435 | }; |
| 4436 | |
| 4437 | } // DOMStorage |
| 4438 | |
| 4439 | namespace Database { |
| 4440 | |
| 4441 | /* Database object. */ |
| 4442 | class Database final : public JSON::ObjectBase { |
| 4443 | public: |
| 4444 | enum { |
| 4445 | NoFieldsSet = 0, |
| 4446 | IdSet = 1 << 0, |
| 4447 | DomainSet = 1 << 1, |
| 4448 | NameSet = 1 << 2, |
| 4449 | VersionSet = 1 << 3, |
| 4450 | AllFieldsSet = (IdSet | DomainSet | NameSet | VersionSet) |
| 4451 | }; |
| 4452 | |
| 4453 | template<int STATE> |
| 4454 | class Builder { |
| 4455 | private: |
| 4456 | RefPtr<JSON::Object> m_result; |
| 4457 | |
| 4458 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4459 | { |
| 4460 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4461 | } |
| 4462 | |
| 4463 | Builder(Ref</*Database*/JSON::Object>&& object) |
| 4464 | : m_result(WTFMove(object)) |
| 4465 | { |
| 4466 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4467 | } |
| 4468 | friend class Database; |
| 4469 | public: |
| 4470 | |
| 4471 | Builder<STATE | IdSet>& setId(const String& in_id) |
| 4472 | { |
| 4473 | COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set); |
| 4474 | m_result->setString("id"_s , in_id); |
| 4475 | return castState<IdSet>(); |
| 4476 | } |
| 4477 | |
| 4478 | Builder<STATE | DomainSet>& setDomain(const String& in_domain) |
| 4479 | { |
| 4480 | COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set); |
| 4481 | m_result->setString("domain"_s , in_domain); |
| 4482 | return castState<DomainSet>(); |
| 4483 | } |
| 4484 | |
| 4485 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 4486 | { |
| 4487 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 4488 | m_result->setString("name"_s , in_name); |
| 4489 | return castState<NameSet>(); |
| 4490 | } |
| 4491 | |
| 4492 | Builder<STATE | VersionSet>& setVersion(const String& in_version) |
| 4493 | { |
| 4494 | COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set); |
| 4495 | m_result->setString("version"_s , in_version); |
| 4496 | return castState<VersionSet>(); |
| 4497 | } |
| 4498 | |
| 4499 | Ref<Database> release() |
| 4500 | { |
| 4501 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4502 | COMPILE_ASSERT(sizeof(Database) == sizeof(JSON::Object), cannot_cast); |
| 4503 | |
| 4504 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4505 | auto result = WTFMove(*reinterpret_cast<Ref<Database>*>(&jsonResult)); |
| 4506 | return result; |
| 4507 | } |
| 4508 | }; |
| 4509 | |
| 4510 | /* |
| 4511 | * Synthetic constructor: |
| 4512 | * Ref<Database> result = Database::create() |
| 4513 | * .setId(...) |
| 4514 | * .setDomain(...) |
| 4515 | * .setName(...) |
| 4516 | * .setVersion(...) |
| 4517 | * .release(); |
| 4518 | */ |
| 4519 | static Builder<NoFieldsSet> create() |
| 4520 | { |
| 4521 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4522 | } |
| 4523 | }; |
| 4524 | |
| 4525 | /* Database error. */ |
| 4526 | class Error final : public JSON::ObjectBase { |
| 4527 | public: |
| 4528 | enum { |
| 4529 | NoFieldsSet = 0, |
| 4530 | MessageSet = 1 << 0, |
| 4531 | CodeSet = 1 << 1, |
| 4532 | AllFieldsSet = (MessageSet | CodeSet) |
| 4533 | }; |
| 4534 | |
| 4535 | template<int STATE> |
| 4536 | class Builder { |
| 4537 | private: |
| 4538 | RefPtr<JSON::Object> m_result; |
| 4539 | |
| 4540 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4541 | { |
| 4542 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4543 | } |
| 4544 | |
| 4545 | Builder(Ref</*Error*/JSON::Object>&& object) |
| 4546 | : m_result(WTFMove(object)) |
| 4547 | { |
| 4548 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4549 | } |
| 4550 | friend class Error; |
| 4551 | public: |
| 4552 | |
| 4553 | Builder<STATE | MessageSet>& setMessage(const String& in_message) |
| 4554 | { |
| 4555 | COMPILE_ASSERT(!(STATE & MessageSet), property_message_already_set); |
| 4556 | m_result->setString("message"_s , in_message); |
| 4557 | return castState<MessageSet>(); |
| 4558 | } |
| 4559 | |
| 4560 | Builder<STATE | CodeSet>& setCode(int in_code) |
| 4561 | { |
| 4562 | COMPILE_ASSERT(!(STATE & CodeSet), property_code_already_set); |
| 4563 | m_result->setInteger("code"_s , in_code); |
| 4564 | return castState<CodeSet>(); |
| 4565 | } |
| 4566 | |
| 4567 | Ref<Error> release() |
| 4568 | { |
| 4569 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4570 | COMPILE_ASSERT(sizeof(Error) == sizeof(JSON::Object), cannot_cast); |
| 4571 | |
| 4572 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4573 | auto result = WTFMove(*reinterpret_cast<Ref<Error>*>(&jsonResult)); |
| 4574 | return result; |
| 4575 | } |
| 4576 | }; |
| 4577 | |
| 4578 | /* |
| 4579 | * Synthetic constructor: |
| 4580 | * Ref<Error> result = Error::create() |
| 4581 | * .setMessage(...) |
| 4582 | * .setCode(...) |
| 4583 | * .release(); |
| 4584 | */ |
| 4585 | static Builder<NoFieldsSet> create() |
| 4586 | { |
| 4587 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4588 | } |
| 4589 | }; |
| 4590 | |
| 4591 | } // Database |
| 4592 | |
| 4593 | namespace Debugger { |
| 4594 | |
| 4595 | /* Location in the source code. */ |
| 4596 | class Location final : public JSON::Object { |
| 4597 | public: |
| 4598 | enum { |
| 4599 | NoFieldsSet = 0, |
| 4600 | ScriptIdSet = 1 << 0, |
| 4601 | LineNumberSet = 1 << 1, |
| 4602 | AllFieldsSet = (ScriptIdSet | LineNumberSet) |
| 4603 | }; |
| 4604 | |
| 4605 | template<int STATE> |
| 4606 | class Builder { |
| 4607 | private: |
| 4608 | RefPtr<JSON::Object> m_result; |
| 4609 | |
| 4610 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4611 | { |
| 4612 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4613 | } |
| 4614 | |
| 4615 | Builder(Ref</*Location*/JSON::Object>&& object) |
| 4616 | : m_result(WTFMove(object)) |
| 4617 | { |
| 4618 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4619 | } |
| 4620 | friend class Location; |
| 4621 | public: |
| 4622 | |
| 4623 | Builder<STATE | ScriptIdSet>& setScriptId(const String& in_scriptId) |
| 4624 | { |
| 4625 | COMPILE_ASSERT(!(STATE & ScriptIdSet), property_scriptId_already_set); |
| 4626 | m_result->setString("scriptId"_s , in_scriptId); |
| 4627 | return castState<ScriptIdSet>(); |
| 4628 | } |
| 4629 | |
| 4630 | Builder<STATE | LineNumberSet>& setLineNumber(int in_lineNumber) |
| 4631 | { |
| 4632 | COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set); |
| 4633 | m_result->setInteger("lineNumber"_s , in_lineNumber); |
| 4634 | return castState<LineNumberSet>(); |
| 4635 | } |
| 4636 | |
| 4637 | Ref<Location> release() |
| 4638 | { |
| 4639 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4640 | COMPILE_ASSERT(sizeof(Location) == sizeof(JSON::Object), cannot_cast); |
| 4641 | |
| 4642 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4643 | auto result = WTFMove(*reinterpret_cast<Ref<Location>*>(&jsonResult)); |
| 4644 | return result; |
| 4645 | } |
| 4646 | }; |
| 4647 | |
| 4648 | /* |
| 4649 | * Synthetic constructor: |
| 4650 | * Ref<Location> result = Location::create() |
| 4651 | * .setScriptId(...) |
| 4652 | * .setLineNumber(...) |
| 4653 | * .release(); |
| 4654 | */ |
| 4655 | static Builder<NoFieldsSet> create() |
| 4656 | { |
| 4657 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4658 | } |
| 4659 | |
| 4660 | void setColumnNumber(int in_opt_columnNumber) |
| 4661 | { |
| 4662 | JSON::ObjectBase::setInteger("columnNumber"_s , in_opt_columnNumber); |
| 4663 | } |
| 4664 | |
| 4665 | // Property names for type generated as open. |
| 4666 | JS_EXPORT_PRIVATE static const ASCIILiteral scriptIdKey; |
| 4667 | JS_EXPORT_PRIVATE static const ASCIILiteral lineNumberKey; |
| 4668 | JS_EXPORT_PRIVATE static const ASCIILiteral columnNumberKey; |
| 4669 | }; |
| 4670 | |
| 4671 | /* Action to perform when a breakpoint is triggered. */ |
| 4672 | class BreakpointAction final : public JSON::Object { |
| 4673 | public: |
| 4674 | // Named after property name 'type' while generating BreakpointAction. |
| 4675 | enum class Type { |
| 4676 | Log = 74, |
| 4677 | Evaluate = 120, |
| 4678 | Sound = 121, |
| 4679 | Probe = 122, |
| 4680 | }; // enum class Type |
| 4681 | |
| 4682 | enum { |
| 4683 | NoFieldsSet = 0, |
| 4684 | TypeSet = 1 << 0, |
| 4685 | AllFieldsSet = (TypeSet) |
| 4686 | }; |
| 4687 | |
| 4688 | template<int STATE> |
| 4689 | class Builder { |
| 4690 | private: |
| 4691 | RefPtr<JSON::Object> m_result; |
| 4692 | |
| 4693 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4694 | { |
| 4695 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4696 | } |
| 4697 | |
| 4698 | Builder(Ref</*BreakpointAction*/JSON::Object>&& object) |
| 4699 | : m_result(WTFMove(object)) |
| 4700 | { |
| 4701 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4702 | } |
| 4703 | friend class BreakpointAction; |
| 4704 | public: |
| 4705 | |
| 4706 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 4707 | { |
| 4708 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 4709 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 4710 | return castState<TypeSet>(); |
| 4711 | } |
| 4712 | |
| 4713 | Ref<BreakpointAction> release() |
| 4714 | { |
| 4715 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4716 | COMPILE_ASSERT(sizeof(BreakpointAction) == sizeof(JSON::Object), cannot_cast); |
| 4717 | |
| 4718 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4719 | auto result = WTFMove(*reinterpret_cast<Ref<BreakpointAction>*>(&jsonResult)); |
| 4720 | return result; |
| 4721 | } |
| 4722 | }; |
| 4723 | |
| 4724 | /* |
| 4725 | * Synthetic constructor: |
| 4726 | * Ref<BreakpointAction> result = BreakpointAction::create() |
| 4727 | * .setType(...) |
| 4728 | * .release(); |
| 4729 | */ |
| 4730 | static Builder<NoFieldsSet> create() |
| 4731 | { |
| 4732 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4733 | } |
| 4734 | |
| 4735 | void setData(const String& in_opt_data) |
| 4736 | { |
| 4737 | JSON::ObjectBase::setString("data"_s , in_opt_data); |
| 4738 | } |
| 4739 | |
| 4740 | void setId(int in_opt_id) |
| 4741 | { |
| 4742 | JSON::ObjectBase::setInteger("id"_s , in_opt_id); |
| 4743 | } |
| 4744 | |
| 4745 | void setEmulateUserGesture(bool in_opt_emulateUserGesture) |
| 4746 | { |
| 4747 | JSON::ObjectBase::setBoolean("emulateUserGesture"_s , in_opt_emulateUserGesture); |
| 4748 | } |
| 4749 | |
| 4750 | // Property names for type generated as open. |
| 4751 | JS_EXPORT_PRIVATE static const ASCIILiteral typeKey; |
| 4752 | JS_EXPORT_PRIVATE static const ASCIILiteral dataKey; |
| 4753 | JS_EXPORT_PRIVATE static const ASCIILiteral idKey; |
| 4754 | JS_EXPORT_PRIVATE static const ASCIILiteral emulateUserGestureKey; |
| 4755 | }; |
| 4756 | |
| 4757 | /* Extra options that modify breakpoint behavior. */ |
| 4758 | class BreakpointOptions final : public JSON::Object { |
| 4759 | public: |
| 4760 | enum { |
| 4761 | NoFieldsSet = 0, |
| 4762 | AllFieldsSet = 0 |
| 4763 | }; |
| 4764 | |
| 4765 | template<int STATE> |
| 4766 | class Builder { |
| 4767 | private: |
| 4768 | RefPtr<JSON::Object> m_result; |
| 4769 | |
| 4770 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4771 | { |
| 4772 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4773 | } |
| 4774 | |
| 4775 | Builder(Ref</*BreakpointOptions*/JSON::Object>&& object) |
| 4776 | : m_result(WTFMove(object)) |
| 4777 | { |
| 4778 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4779 | } |
| 4780 | friend class BreakpointOptions; |
| 4781 | public: |
| 4782 | |
| 4783 | Ref<BreakpointOptions> release() |
| 4784 | { |
| 4785 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4786 | COMPILE_ASSERT(sizeof(BreakpointOptions) == sizeof(JSON::Object), cannot_cast); |
| 4787 | |
| 4788 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4789 | auto result = WTFMove(*reinterpret_cast<Ref<BreakpointOptions>*>(&jsonResult)); |
| 4790 | return result; |
| 4791 | } |
| 4792 | }; |
| 4793 | |
| 4794 | /* |
| 4795 | * Synthetic constructor: |
| 4796 | * Ref<BreakpointOptions> result = BreakpointOptions::create() |
| 4797 | * .release(); |
| 4798 | */ |
| 4799 | static Builder<NoFieldsSet> create() |
| 4800 | { |
| 4801 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4802 | } |
| 4803 | |
| 4804 | void setCondition(const String& in_opt_condition) |
| 4805 | { |
| 4806 | JSON::ObjectBase::setString("condition"_s , in_opt_condition); |
| 4807 | } |
| 4808 | |
| 4809 | void setActions(Ref<JSON::ArrayOf<Protocol::Debugger::BreakpointAction>>&& in_opt_actions) |
| 4810 | { |
| 4811 | JSON::ObjectBase::setArray("actions"_s , WTFMove(in_opt_actions)); |
| 4812 | } |
| 4813 | |
| 4814 | void setAutoContinue(bool in_opt_autoContinue) |
| 4815 | { |
| 4816 | JSON::ObjectBase::setBoolean("autoContinue"_s , in_opt_autoContinue); |
| 4817 | } |
| 4818 | |
| 4819 | void setIgnoreCount(int in_opt_ignoreCount) |
| 4820 | { |
| 4821 | JSON::ObjectBase::setInteger("ignoreCount"_s , in_opt_ignoreCount); |
| 4822 | } |
| 4823 | |
| 4824 | // Property names for type generated as open. |
| 4825 | JS_EXPORT_PRIVATE static const ASCIILiteral conditionKey; |
| 4826 | JS_EXPORT_PRIVATE static const ASCIILiteral actionsKey; |
| 4827 | JS_EXPORT_PRIVATE static const ASCIILiteral autoContinueKey; |
| 4828 | JS_EXPORT_PRIVATE static const ASCIILiteral ignoreCountKey; |
| 4829 | }; |
| 4830 | |
| 4831 | /* Information about the function. */ |
| 4832 | class FunctionDetails final : public JSON::ObjectBase { |
| 4833 | public: |
| 4834 | enum { |
| 4835 | NoFieldsSet = 0, |
| 4836 | LocationSet = 1 << 0, |
| 4837 | AllFieldsSet = (LocationSet) |
| 4838 | }; |
| 4839 | |
| 4840 | template<int STATE> |
| 4841 | class Builder { |
| 4842 | private: |
| 4843 | RefPtr<JSON::Object> m_result; |
| 4844 | |
| 4845 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4846 | { |
| 4847 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4848 | } |
| 4849 | |
| 4850 | Builder(Ref</*FunctionDetails*/JSON::Object>&& object) |
| 4851 | : m_result(WTFMove(object)) |
| 4852 | { |
| 4853 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4854 | } |
| 4855 | friend class FunctionDetails; |
| 4856 | public: |
| 4857 | |
| 4858 | Builder<STATE | LocationSet>& setLocation(Ref<Protocol::Debugger::Location>&& in_location) |
| 4859 | { |
| 4860 | COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set); |
| 4861 | m_result->setObject("location"_s , WTFMove(in_location)); |
| 4862 | return castState<LocationSet>(); |
| 4863 | } |
| 4864 | |
| 4865 | Ref<FunctionDetails> release() |
| 4866 | { |
| 4867 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4868 | COMPILE_ASSERT(sizeof(FunctionDetails) == sizeof(JSON::Object), cannot_cast); |
| 4869 | |
| 4870 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4871 | auto result = WTFMove(*reinterpret_cast<Ref<FunctionDetails>*>(&jsonResult)); |
| 4872 | return result; |
| 4873 | } |
| 4874 | }; |
| 4875 | |
| 4876 | /* |
| 4877 | * Synthetic constructor: |
| 4878 | * Ref<FunctionDetails> result = FunctionDetails::create() |
| 4879 | * .setLocation(...) |
| 4880 | * .release(); |
| 4881 | */ |
| 4882 | static Builder<NoFieldsSet> create() |
| 4883 | { |
| 4884 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 4885 | } |
| 4886 | |
| 4887 | void setName(const String& in_opt_name) |
| 4888 | { |
| 4889 | JSON::ObjectBase::setString("name"_s , in_opt_name); |
| 4890 | } |
| 4891 | |
| 4892 | void setDisplayName(const String& in_opt_displayName) |
| 4893 | { |
| 4894 | JSON::ObjectBase::setString("displayName"_s , in_opt_displayName); |
| 4895 | } |
| 4896 | |
| 4897 | void setScopeChain(Ref<JSON::ArrayOf<Protocol::Debugger::Scope>>&& in_opt_scopeChain) |
| 4898 | { |
| 4899 | JSON::ObjectBase::setArray("scopeChain"_s , WTFMove(in_opt_scopeChain)); |
| 4900 | } |
| 4901 | }; |
| 4902 | |
| 4903 | /* JavaScript call frame. Array of call frames form the call stack. */ |
| 4904 | class CallFrame final : public JSON::ObjectBase { |
| 4905 | public: |
| 4906 | enum { |
| 4907 | NoFieldsSet = 0, |
| 4908 | CallFrameIdSet = 1 << 0, |
| 4909 | FunctionNameSet = 1 << 1, |
| 4910 | LocationSet = 1 << 2, |
| 4911 | ScopeChainSet = 1 << 3, |
| 4912 | ThisSet = 1 << 4, |
| 4913 | IsTailDeletedSet = 1 << 5, |
| 4914 | AllFieldsSet = (CallFrameIdSet | FunctionNameSet | LocationSet | ScopeChainSet | ThisSet | IsTailDeletedSet) |
| 4915 | }; |
| 4916 | |
| 4917 | template<int STATE> |
| 4918 | class Builder { |
| 4919 | private: |
| 4920 | RefPtr<JSON::Object> m_result; |
| 4921 | |
| 4922 | template<int STEP> Builder<STATE | STEP>& castState() |
| 4923 | { |
| 4924 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 4925 | } |
| 4926 | |
| 4927 | Builder(Ref</*CallFrame*/JSON::Object>&& object) |
| 4928 | : m_result(WTFMove(object)) |
| 4929 | { |
| 4930 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 4931 | } |
| 4932 | friend class CallFrame; |
| 4933 | public: |
| 4934 | |
| 4935 | Builder<STATE | CallFrameIdSet>& setCallFrameId(const String& in_callFrameId) |
| 4936 | { |
| 4937 | COMPILE_ASSERT(!(STATE & CallFrameIdSet), property_callFrameId_already_set); |
| 4938 | m_result->setString("callFrameId"_s , in_callFrameId); |
| 4939 | return castState<CallFrameIdSet>(); |
| 4940 | } |
| 4941 | |
| 4942 | Builder<STATE | FunctionNameSet>& setFunctionName(const String& in_functionName) |
| 4943 | { |
| 4944 | COMPILE_ASSERT(!(STATE & FunctionNameSet), property_functionName_already_set); |
| 4945 | m_result->setString("functionName"_s , in_functionName); |
| 4946 | return castState<FunctionNameSet>(); |
| 4947 | } |
| 4948 | |
| 4949 | Builder<STATE | LocationSet>& setLocation(Ref<Protocol::Debugger::Location>&& in_location) |
| 4950 | { |
| 4951 | COMPILE_ASSERT(!(STATE & LocationSet), property_location_already_set); |
| 4952 | m_result->setObject("location"_s , WTFMove(in_location)); |
| 4953 | return castState<LocationSet>(); |
| 4954 | } |
| 4955 | |
| 4956 | Builder<STATE | ScopeChainSet>& setScopeChain(Ref<JSON::ArrayOf<Protocol::Debugger::Scope>>&& in_scopeChain) |
| 4957 | { |
| 4958 | COMPILE_ASSERT(!(STATE & ScopeChainSet), property_scopeChain_already_set); |
| 4959 | m_result->setArray("scopeChain"_s , WTFMove(in_scopeChain)); |
| 4960 | return castState<ScopeChainSet>(); |
| 4961 | } |
| 4962 | |
| 4963 | Builder<STATE | ThisSet>& setThis(Ref<Protocol::Runtime::RemoteObject>&& in_this) |
| 4964 | { |
| 4965 | COMPILE_ASSERT(!(STATE & ThisSet), property_this_already_set); |
| 4966 | m_result->setObject("this"_s , WTFMove(in_this)); |
| 4967 | return castState<ThisSet>(); |
| 4968 | } |
| 4969 | |
| 4970 | Builder<STATE | IsTailDeletedSet>& setIsTailDeleted(bool in_isTailDeleted) |
| 4971 | { |
| 4972 | COMPILE_ASSERT(!(STATE & IsTailDeletedSet), property_isTailDeleted_already_set); |
| 4973 | m_result->setBoolean("isTailDeleted"_s , in_isTailDeleted); |
| 4974 | return castState<IsTailDeletedSet>(); |
| 4975 | } |
| 4976 | |
| 4977 | Ref<CallFrame> release() |
| 4978 | { |
| 4979 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 4980 | COMPILE_ASSERT(sizeof(CallFrame) == sizeof(JSON::Object), cannot_cast); |
| 4981 | |
| 4982 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 4983 | auto result = WTFMove(*reinterpret_cast<Ref<CallFrame>*>(&jsonResult)); |
| 4984 | return result; |
| 4985 | } |
| 4986 | }; |
| 4987 | |
| 4988 | /* |
| 4989 | * Synthetic constructor: |
| 4990 | * Ref<CallFrame> result = CallFrame::create() |
| 4991 | * .setCallFrameId(...) |
| 4992 | * .setFunctionName(...) |
| 4993 | * .setLocation(...) |
| 4994 | * .setScopeChain(...) |
| 4995 | * .setThis(...) |
| 4996 | * .setIsTailDeleted(...) |
| 4997 | * .release(); |
| 4998 | */ |
| 4999 | static Builder<NoFieldsSet> create() |
| 5000 | { |
| 5001 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5002 | } |
| 5003 | }; |
| 5004 | |
| 5005 | /* Scope description. */ |
| 5006 | class Scope final : public JSON::ObjectBase { |
| 5007 | public: |
| 5008 | // Named after property name 'type' while generating Scope. |
| 5009 | enum class Type { |
| 5010 | Global = 123, |
| 5011 | With = 124, |
| 5012 | Closure = 125, |
| 5013 | Catch = 126, |
| 5014 | FunctionName = 127, |
| 5015 | GlobalLexicalEnvironment = 128, |
| 5016 | NestedLexical = 129, |
| 5017 | }; // enum class Type |
| 5018 | |
| 5019 | enum { |
| 5020 | NoFieldsSet = 0, |
| 5021 | ObjectSet = 1 << 0, |
| 5022 | TypeSet = 1 << 1, |
| 5023 | AllFieldsSet = (ObjectSet | TypeSet) |
| 5024 | }; |
| 5025 | |
| 5026 | template<int STATE> |
| 5027 | class Builder { |
| 5028 | private: |
| 5029 | RefPtr<JSON::Object> m_result; |
| 5030 | |
| 5031 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5032 | { |
| 5033 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5034 | } |
| 5035 | |
| 5036 | Builder(Ref</*Scope*/JSON::Object>&& object) |
| 5037 | : m_result(WTFMove(object)) |
| 5038 | { |
| 5039 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5040 | } |
| 5041 | friend class Scope; |
| 5042 | public: |
| 5043 | |
| 5044 | Builder<STATE | ObjectSet>& setObject(Ref<Protocol::Runtime::RemoteObject>&& in_object) |
| 5045 | { |
| 5046 | COMPILE_ASSERT(!(STATE & ObjectSet), property_object_already_set); |
| 5047 | m_result->setObject("object"_s , WTFMove(in_object)); |
| 5048 | return castState<ObjectSet>(); |
| 5049 | } |
| 5050 | |
| 5051 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 5052 | { |
| 5053 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 5054 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 5055 | return castState<TypeSet>(); |
| 5056 | } |
| 5057 | |
| 5058 | Ref<Scope> release() |
| 5059 | { |
| 5060 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5061 | COMPILE_ASSERT(sizeof(Scope) == sizeof(JSON::Object), cannot_cast); |
| 5062 | |
| 5063 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5064 | auto result = WTFMove(*reinterpret_cast<Ref<Scope>*>(&jsonResult)); |
| 5065 | return result; |
| 5066 | } |
| 5067 | }; |
| 5068 | |
| 5069 | /* |
| 5070 | * Synthetic constructor: |
| 5071 | * Ref<Scope> result = Scope::create() |
| 5072 | * .setObject(...) |
| 5073 | * .setType(...) |
| 5074 | * .release(); |
| 5075 | */ |
| 5076 | static Builder<NoFieldsSet> create() |
| 5077 | { |
| 5078 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5079 | } |
| 5080 | |
| 5081 | void setName(const String& in_opt_name) |
| 5082 | { |
| 5083 | JSON::ObjectBase::setString("name"_s , in_opt_name); |
| 5084 | } |
| 5085 | |
| 5086 | void setLocation(Ref<Protocol::Debugger::Location>&& in_opt_location) |
| 5087 | { |
| 5088 | JSON::ObjectBase::setObject("location"_s , WTFMove(in_opt_location)); |
| 5089 | } |
| 5090 | |
| 5091 | void setEmpty(bool in_opt_empty) |
| 5092 | { |
| 5093 | JSON::ObjectBase::setBoolean("empty"_s , in_opt_empty); |
| 5094 | } |
| 5095 | }; |
| 5096 | |
| 5097 | /* A sample collected by evaluating a probe breakpoint action. */ |
| 5098 | class ProbeSample final : public JSON::ObjectBase { |
| 5099 | public: |
| 5100 | enum { |
| 5101 | NoFieldsSet = 0, |
| 5102 | ProbeIdSet = 1 << 0, |
| 5103 | SampleIdSet = 1 << 1, |
| 5104 | BatchIdSet = 1 << 2, |
| 5105 | TimestampSet = 1 << 3, |
| 5106 | PayloadSet = 1 << 4, |
| 5107 | AllFieldsSet = (ProbeIdSet | SampleIdSet | BatchIdSet | TimestampSet | PayloadSet) |
| 5108 | }; |
| 5109 | |
| 5110 | template<int STATE> |
| 5111 | class Builder { |
| 5112 | private: |
| 5113 | RefPtr<JSON::Object> m_result; |
| 5114 | |
| 5115 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5116 | { |
| 5117 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5118 | } |
| 5119 | |
| 5120 | Builder(Ref</*ProbeSample*/JSON::Object>&& object) |
| 5121 | : m_result(WTFMove(object)) |
| 5122 | { |
| 5123 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5124 | } |
| 5125 | friend class ProbeSample; |
| 5126 | public: |
| 5127 | |
| 5128 | Builder<STATE | ProbeIdSet>& setProbeId(int in_probeId) |
| 5129 | { |
| 5130 | COMPILE_ASSERT(!(STATE & ProbeIdSet), property_probeId_already_set); |
| 5131 | m_result->setInteger("probeId"_s , in_probeId); |
| 5132 | return castState<ProbeIdSet>(); |
| 5133 | } |
| 5134 | |
| 5135 | Builder<STATE | SampleIdSet>& setSampleId(int in_sampleId) |
| 5136 | { |
| 5137 | COMPILE_ASSERT(!(STATE & SampleIdSet), property_sampleId_already_set); |
| 5138 | m_result->setInteger("sampleId"_s , in_sampleId); |
| 5139 | return castState<SampleIdSet>(); |
| 5140 | } |
| 5141 | |
| 5142 | Builder<STATE | BatchIdSet>& setBatchId(int in_batchId) |
| 5143 | { |
| 5144 | COMPILE_ASSERT(!(STATE & BatchIdSet), property_batchId_already_set); |
| 5145 | m_result->setInteger("batchId"_s , in_batchId); |
| 5146 | return castState<BatchIdSet>(); |
| 5147 | } |
| 5148 | |
| 5149 | Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp) |
| 5150 | { |
| 5151 | COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set); |
| 5152 | m_result->setDouble("timestamp"_s , in_timestamp); |
| 5153 | return castState<TimestampSet>(); |
| 5154 | } |
| 5155 | |
| 5156 | Builder<STATE | PayloadSet>& setPayload(Ref<Protocol::Runtime::RemoteObject>&& in_payload) |
| 5157 | { |
| 5158 | COMPILE_ASSERT(!(STATE & PayloadSet), property_payload_already_set); |
| 5159 | m_result->setObject("payload"_s , WTFMove(in_payload)); |
| 5160 | return castState<PayloadSet>(); |
| 5161 | } |
| 5162 | |
| 5163 | Ref<ProbeSample> release() |
| 5164 | { |
| 5165 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5166 | COMPILE_ASSERT(sizeof(ProbeSample) == sizeof(JSON::Object), cannot_cast); |
| 5167 | |
| 5168 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5169 | auto result = WTFMove(*reinterpret_cast<Ref<ProbeSample>*>(&jsonResult)); |
| 5170 | return result; |
| 5171 | } |
| 5172 | }; |
| 5173 | |
| 5174 | /* |
| 5175 | * Synthetic constructor: |
| 5176 | * Ref<ProbeSample> result = ProbeSample::create() |
| 5177 | * .setProbeId(...) |
| 5178 | * .setSampleId(...) |
| 5179 | * .setBatchId(...) |
| 5180 | * .setTimestamp(...) |
| 5181 | * .setPayload(...) |
| 5182 | * .release(); |
| 5183 | */ |
| 5184 | static Builder<NoFieldsSet> create() |
| 5185 | { |
| 5186 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5187 | } |
| 5188 | }; |
| 5189 | |
| 5190 | /* The pause reason auxiliary data when paused because of an assertion. */ |
| 5191 | class AssertPauseReason final : public JSON::ObjectBase { |
| 5192 | public: |
| 5193 | enum { |
| 5194 | NoFieldsSet = 0, |
| 5195 | AllFieldsSet = 0 |
| 5196 | }; |
| 5197 | |
| 5198 | template<int STATE> |
| 5199 | class Builder { |
| 5200 | private: |
| 5201 | RefPtr<JSON::Object> m_result; |
| 5202 | |
| 5203 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5204 | { |
| 5205 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5206 | } |
| 5207 | |
| 5208 | Builder(Ref</*AssertPauseReason*/JSON::Object>&& object) |
| 5209 | : m_result(WTFMove(object)) |
| 5210 | { |
| 5211 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5212 | } |
| 5213 | friend class AssertPauseReason; |
| 5214 | public: |
| 5215 | |
| 5216 | Ref<AssertPauseReason> release() |
| 5217 | { |
| 5218 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5219 | COMPILE_ASSERT(sizeof(AssertPauseReason) == sizeof(JSON::Object), cannot_cast); |
| 5220 | |
| 5221 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5222 | auto result = WTFMove(*reinterpret_cast<Ref<AssertPauseReason>*>(&jsonResult)); |
| 5223 | return result; |
| 5224 | } |
| 5225 | }; |
| 5226 | |
| 5227 | /* |
| 5228 | * Synthetic constructor: |
| 5229 | * Ref<AssertPauseReason> result = AssertPauseReason::create() |
| 5230 | * .release(); |
| 5231 | */ |
| 5232 | static Builder<NoFieldsSet> create() |
| 5233 | { |
| 5234 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5235 | } |
| 5236 | |
| 5237 | void setMessage(const String& in_opt_message) |
| 5238 | { |
| 5239 | JSON::ObjectBase::setString("message"_s , in_opt_message); |
| 5240 | } |
| 5241 | }; |
| 5242 | |
| 5243 | /* The pause reason auxiliary data when paused because of hitting a breakpoint. */ |
| 5244 | class BreakpointPauseReason final : public JSON::ObjectBase { |
| 5245 | public: |
| 5246 | enum { |
| 5247 | NoFieldsSet = 0, |
| 5248 | BreakpointIdSet = 1 << 0, |
| 5249 | AllFieldsSet = (BreakpointIdSet) |
| 5250 | }; |
| 5251 | |
| 5252 | template<int STATE> |
| 5253 | class Builder { |
| 5254 | private: |
| 5255 | RefPtr<JSON::Object> m_result; |
| 5256 | |
| 5257 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5258 | { |
| 5259 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5260 | } |
| 5261 | |
| 5262 | Builder(Ref</*BreakpointPauseReason*/JSON::Object>&& object) |
| 5263 | : m_result(WTFMove(object)) |
| 5264 | { |
| 5265 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5266 | } |
| 5267 | friend class BreakpointPauseReason; |
| 5268 | public: |
| 5269 | |
| 5270 | Builder<STATE | BreakpointIdSet>& setBreakpointId(const String& in_breakpointId) |
| 5271 | { |
| 5272 | COMPILE_ASSERT(!(STATE & BreakpointIdSet), property_breakpointId_already_set); |
| 5273 | m_result->setString("breakpointId"_s , in_breakpointId); |
| 5274 | return castState<BreakpointIdSet>(); |
| 5275 | } |
| 5276 | |
| 5277 | Ref<BreakpointPauseReason> release() |
| 5278 | { |
| 5279 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5280 | COMPILE_ASSERT(sizeof(BreakpointPauseReason) == sizeof(JSON::Object), cannot_cast); |
| 5281 | |
| 5282 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5283 | auto result = WTFMove(*reinterpret_cast<Ref<BreakpointPauseReason>*>(&jsonResult)); |
| 5284 | return result; |
| 5285 | } |
| 5286 | }; |
| 5287 | |
| 5288 | /* |
| 5289 | * Synthetic constructor: |
| 5290 | * Ref<BreakpointPauseReason> result = BreakpointPauseReason::create() |
| 5291 | * .setBreakpointId(...) |
| 5292 | * .release(); |
| 5293 | */ |
| 5294 | static Builder<NoFieldsSet> create() |
| 5295 | { |
| 5296 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5297 | } |
| 5298 | }; |
| 5299 | |
| 5300 | /* The pause reason auxiliary data when paused because of a Content Security Policy directive. */ |
| 5301 | class CSPViolationPauseReason final : public JSON::ObjectBase { |
| 5302 | public: |
| 5303 | enum { |
| 5304 | NoFieldsSet = 0, |
| 5305 | DirectiveSet = 1 << 0, |
| 5306 | AllFieldsSet = (DirectiveSet) |
| 5307 | }; |
| 5308 | |
| 5309 | template<int STATE> |
| 5310 | class Builder { |
| 5311 | private: |
| 5312 | RefPtr<JSON::Object> m_result; |
| 5313 | |
| 5314 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5315 | { |
| 5316 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5317 | } |
| 5318 | |
| 5319 | Builder(Ref</*CSPViolationPauseReason*/JSON::Object>&& object) |
| 5320 | : m_result(WTFMove(object)) |
| 5321 | { |
| 5322 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5323 | } |
| 5324 | friend class CSPViolationPauseReason; |
| 5325 | public: |
| 5326 | |
| 5327 | Builder<STATE | DirectiveSet>& setDirective(const String& in_directive) |
| 5328 | { |
| 5329 | COMPILE_ASSERT(!(STATE & DirectiveSet), property_directive_already_set); |
| 5330 | m_result->setString("directive"_s , in_directive); |
| 5331 | return castState<DirectiveSet>(); |
| 5332 | } |
| 5333 | |
| 5334 | Ref<CSPViolationPauseReason> release() |
| 5335 | { |
| 5336 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5337 | COMPILE_ASSERT(sizeof(CSPViolationPauseReason) == sizeof(JSON::Object), cannot_cast); |
| 5338 | |
| 5339 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5340 | auto result = WTFMove(*reinterpret_cast<Ref<CSPViolationPauseReason>*>(&jsonResult)); |
| 5341 | return result; |
| 5342 | } |
| 5343 | }; |
| 5344 | |
| 5345 | /* |
| 5346 | * Synthetic constructor: |
| 5347 | * Ref<CSPViolationPauseReason> result = CSPViolationPauseReason::create() |
| 5348 | * .setDirective(...) |
| 5349 | * .release(); |
| 5350 | */ |
| 5351 | static Builder<NoFieldsSet> create() |
| 5352 | { |
| 5353 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5354 | } |
| 5355 | }; |
| 5356 | |
| 5357 | } // Debugger |
| 5358 | |
| 5359 | namespace GenericTypes { |
| 5360 | |
| 5361 | /* Search match in a resource. */ |
| 5362 | class SearchMatch final : public JSON::ObjectBase { |
| 5363 | public: |
| 5364 | enum { |
| 5365 | NoFieldsSet = 0, |
| 5366 | LineNumberSet = 1 << 0, |
| 5367 | LineContentSet = 1 << 1, |
| 5368 | AllFieldsSet = (LineNumberSet | LineContentSet) |
| 5369 | }; |
| 5370 | |
| 5371 | template<int STATE> |
| 5372 | class Builder { |
| 5373 | private: |
| 5374 | RefPtr<JSON::Object> m_result; |
| 5375 | |
| 5376 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5377 | { |
| 5378 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5379 | } |
| 5380 | |
| 5381 | Builder(Ref</*SearchMatch*/JSON::Object>&& object) |
| 5382 | : m_result(WTFMove(object)) |
| 5383 | { |
| 5384 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5385 | } |
| 5386 | friend class SearchMatch; |
| 5387 | public: |
| 5388 | |
| 5389 | Builder<STATE | LineNumberSet>& setLineNumber(double in_lineNumber) |
| 5390 | { |
| 5391 | COMPILE_ASSERT(!(STATE & LineNumberSet), property_lineNumber_already_set); |
| 5392 | m_result->setDouble("lineNumber"_s , in_lineNumber); |
| 5393 | return castState<LineNumberSet>(); |
| 5394 | } |
| 5395 | |
| 5396 | Builder<STATE | LineContentSet>& setLineContent(const String& in_lineContent) |
| 5397 | { |
| 5398 | COMPILE_ASSERT(!(STATE & LineContentSet), property_lineContent_already_set); |
| 5399 | m_result->setString("lineContent"_s , in_lineContent); |
| 5400 | return castState<LineContentSet>(); |
| 5401 | } |
| 5402 | |
| 5403 | Ref<SearchMatch> release() |
| 5404 | { |
| 5405 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5406 | COMPILE_ASSERT(sizeof(SearchMatch) == sizeof(JSON::Object), cannot_cast); |
| 5407 | |
| 5408 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5409 | auto result = WTFMove(*reinterpret_cast<Ref<SearchMatch>*>(&jsonResult)); |
| 5410 | return result; |
| 5411 | } |
| 5412 | }; |
| 5413 | |
| 5414 | /* |
| 5415 | * Synthetic constructor: |
| 5416 | * Ref<SearchMatch> result = SearchMatch::create() |
| 5417 | * .setLineNumber(...) |
| 5418 | * .setLineContent(...) |
| 5419 | * .release(); |
| 5420 | */ |
| 5421 | static Builder<NoFieldsSet> create() |
| 5422 | { |
| 5423 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5424 | } |
| 5425 | }; |
| 5426 | |
| 5427 | } // GenericTypes |
| 5428 | |
| 5429 | namespace Heap { |
| 5430 | |
| 5431 | /* Information about a garbage collection. */ |
| 5432 | class GarbageCollection final : public JSON::ObjectBase { |
| 5433 | public: |
| 5434 | // Named after property name 'type' while generating GarbageCollection. |
| 5435 | enum class Type { |
| 5436 | Full = 130, |
| 5437 | Partial = 131, |
| 5438 | }; // enum class Type |
| 5439 | |
| 5440 | enum { |
| 5441 | NoFieldsSet = 0, |
| 5442 | TypeSet = 1 << 0, |
| 5443 | StartTimeSet = 1 << 1, |
| 5444 | EndTimeSet = 1 << 2, |
| 5445 | AllFieldsSet = (TypeSet | StartTimeSet | EndTimeSet) |
| 5446 | }; |
| 5447 | |
| 5448 | template<int STATE> |
| 5449 | class Builder { |
| 5450 | private: |
| 5451 | RefPtr<JSON::Object> m_result; |
| 5452 | |
| 5453 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5454 | { |
| 5455 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5456 | } |
| 5457 | |
| 5458 | Builder(Ref</*GarbageCollection*/JSON::Object>&& object) |
| 5459 | : m_result(WTFMove(object)) |
| 5460 | { |
| 5461 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5462 | } |
| 5463 | friend class GarbageCollection; |
| 5464 | public: |
| 5465 | |
| 5466 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 5467 | { |
| 5468 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 5469 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 5470 | return castState<TypeSet>(); |
| 5471 | } |
| 5472 | |
| 5473 | Builder<STATE | StartTimeSet>& setStartTime(double in_startTime) |
| 5474 | { |
| 5475 | COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set); |
| 5476 | m_result->setDouble("startTime"_s , in_startTime); |
| 5477 | return castState<StartTimeSet>(); |
| 5478 | } |
| 5479 | |
| 5480 | Builder<STATE | EndTimeSet>& setEndTime(double in_endTime) |
| 5481 | { |
| 5482 | COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set); |
| 5483 | m_result->setDouble("endTime"_s , in_endTime); |
| 5484 | return castState<EndTimeSet>(); |
| 5485 | } |
| 5486 | |
| 5487 | Ref<GarbageCollection> release() |
| 5488 | { |
| 5489 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5490 | COMPILE_ASSERT(sizeof(GarbageCollection) == sizeof(JSON::Object), cannot_cast); |
| 5491 | |
| 5492 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5493 | auto result = WTFMove(*reinterpret_cast<Ref<GarbageCollection>*>(&jsonResult)); |
| 5494 | return result; |
| 5495 | } |
| 5496 | }; |
| 5497 | |
| 5498 | /* |
| 5499 | * Synthetic constructor: |
| 5500 | * Ref<GarbageCollection> result = GarbageCollection::create() |
| 5501 | * .setType(...) |
| 5502 | * .setStartTime(...) |
| 5503 | * .setEndTime(...) |
| 5504 | * .release(); |
| 5505 | */ |
| 5506 | static Builder<NoFieldsSet> create() |
| 5507 | { |
| 5508 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5509 | } |
| 5510 | }; |
| 5511 | |
| 5512 | } // Heap |
| 5513 | |
| 5514 | namespace IndexedDB { |
| 5515 | |
| 5516 | /* Database with an array of object stores. */ |
| 5517 | class DatabaseWithObjectStores final : public JSON::ObjectBase { |
| 5518 | public: |
| 5519 | enum { |
| 5520 | NoFieldsSet = 0, |
| 5521 | NameSet = 1 << 0, |
| 5522 | VersionSet = 1 << 1, |
| 5523 | ObjectStoresSet = 1 << 2, |
| 5524 | AllFieldsSet = (NameSet | VersionSet | ObjectStoresSet) |
| 5525 | }; |
| 5526 | |
| 5527 | template<int STATE> |
| 5528 | class Builder { |
| 5529 | private: |
| 5530 | RefPtr<JSON::Object> m_result; |
| 5531 | |
| 5532 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5533 | { |
| 5534 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5535 | } |
| 5536 | |
| 5537 | Builder(Ref</*DatabaseWithObjectStores*/JSON::Object>&& object) |
| 5538 | : m_result(WTFMove(object)) |
| 5539 | { |
| 5540 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5541 | } |
| 5542 | friend class DatabaseWithObjectStores; |
| 5543 | public: |
| 5544 | |
| 5545 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 5546 | { |
| 5547 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 5548 | m_result->setString("name"_s , in_name); |
| 5549 | return castState<NameSet>(); |
| 5550 | } |
| 5551 | |
| 5552 | Builder<STATE | VersionSet>& setVersion(double in_version) |
| 5553 | { |
| 5554 | COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set); |
| 5555 | m_result->setDouble("version"_s , in_version); |
| 5556 | return castState<VersionSet>(); |
| 5557 | } |
| 5558 | |
| 5559 | Builder<STATE | ObjectStoresSet>& setObjectStores(Ref<JSON::ArrayOf<Protocol::IndexedDB::ObjectStore>>&& in_objectStores) |
| 5560 | { |
| 5561 | COMPILE_ASSERT(!(STATE & ObjectStoresSet), property_objectStores_already_set); |
| 5562 | m_result->setArray("objectStores"_s , WTFMove(in_objectStores)); |
| 5563 | return castState<ObjectStoresSet>(); |
| 5564 | } |
| 5565 | |
| 5566 | Ref<DatabaseWithObjectStores> release() |
| 5567 | { |
| 5568 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5569 | COMPILE_ASSERT(sizeof(DatabaseWithObjectStores) == sizeof(JSON::Object), cannot_cast); |
| 5570 | |
| 5571 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5572 | auto result = WTFMove(*reinterpret_cast<Ref<DatabaseWithObjectStores>*>(&jsonResult)); |
| 5573 | return result; |
| 5574 | } |
| 5575 | }; |
| 5576 | |
| 5577 | /* |
| 5578 | * Synthetic constructor: |
| 5579 | * Ref<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create() |
| 5580 | * .setName(...) |
| 5581 | * .setVersion(...) |
| 5582 | * .setObjectStores(...) |
| 5583 | * .release(); |
| 5584 | */ |
| 5585 | static Builder<NoFieldsSet> create() |
| 5586 | { |
| 5587 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5588 | } |
| 5589 | }; |
| 5590 | |
| 5591 | /* Object store. */ |
| 5592 | class ObjectStore final : public JSON::ObjectBase { |
| 5593 | public: |
| 5594 | enum { |
| 5595 | NoFieldsSet = 0, |
| 5596 | NameSet = 1 << 0, |
| 5597 | KeyPathSet = 1 << 1, |
| 5598 | AutoIncrementSet = 1 << 2, |
| 5599 | IndexesSet = 1 << 3, |
| 5600 | AllFieldsSet = (NameSet | KeyPathSet | AutoIncrementSet | IndexesSet) |
| 5601 | }; |
| 5602 | |
| 5603 | template<int STATE> |
| 5604 | class Builder { |
| 5605 | private: |
| 5606 | RefPtr<JSON::Object> m_result; |
| 5607 | |
| 5608 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5609 | { |
| 5610 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5611 | } |
| 5612 | |
| 5613 | Builder(Ref</*ObjectStore*/JSON::Object>&& object) |
| 5614 | : m_result(WTFMove(object)) |
| 5615 | { |
| 5616 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5617 | } |
| 5618 | friend class ObjectStore; |
| 5619 | public: |
| 5620 | |
| 5621 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 5622 | { |
| 5623 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 5624 | m_result->setString("name"_s , in_name); |
| 5625 | return castState<NameSet>(); |
| 5626 | } |
| 5627 | |
| 5628 | Builder<STATE | KeyPathSet>& setKeyPath(Ref<Protocol::IndexedDB::KeyPath>&& in_keyPath) |
| 5629 | { |
| 5630 | COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set); |
| 5631 | m_result->setObject("keyPath"_s , WTFMove(in_keyPath)); |
| 5632 | return castState<KeyPathSet>(); |
| 5633 | } |
| 5634 | |
| 5635 | Builder<STATE | AutoIncrementSet>& setAutoIncrement(bool in_autoIncrement) |
| 5636 | { |
| 5637 | COMPILE_ASSERT(!(STATE & AutoIncrementSet), property_autoIncrement_already_set); |
| 5638 | m_result->setBoolean("autoIncrement"_s , in_autoIncrement); |
| 5639 | return castState<AutoIncrementSet>(); |
| 5640 | } |
| 5641 | |
| 5642 | Builder<STATE | IndexesSet>& setIndexes(Ref<JSON::ArrayOf<Protocol::IndexedDB::ObjectStoreIndex>>&& in_indexes) |
| 5643 | { |
| 5644 | COMPILE_ASSERT(!(STATE & IndexesSet), property_indexes_already_set); |
| 5645 | m_result->setArray("indexes"_s , WTFMove(in_indexes)); |
| 5646 | return castState<IndexesSet>(); |
| 5647 | } |
| 5648 | |
| 5649 | Ref<ObjectStore> release() |
| 5650 | { |
| 5651 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5652 | COMPILE_ASSERT(sizeof(ObjectStore) == sizeof(JSON::Object), cannot_cast); |
| 5653 | |
| 5654 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5655 | auto result = WTFMove(*reinterpret_cast<Ref<ObjectStore>*>(&jsonResult)); |
| 5656 | return result; |
| 5657 | } |
| 5658 | }; |
| 5659 | |
| 5660 | /* |
| 5661 | * Synthetic constructor: |
| 5662 | * Ref<ObjectStore> result = ObjectStore::create() |
| 5663 | * .setName(...) |
| 5664 | * .setKeyPath(...) |
| 5665 | * .setAutoIncrement(...) |
| 5666 | * .setIndexes(...) |
| 5667 | * .release(); |
| 5668 | */ |
| 5669 | static Builder<NoFieldsSet> create() |
| 5670 | { |
| 5671 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5672 | } |
| 5673 | }; |
| 5674 | |
| 5675 | /* Object store index. */ |
| 5676 | class ObjectStoreIndex final : public JSON::ObjectBase { |
| 5677 | public: |
| 5678 | enum { |
| 5679 | NoFieldsSet = 0, |
| 5680 | NameSet = 1 << 0, |
| 5681 | KeyPathSet = 1 << 1, |
| 5682 | UniqueSet = 1 << 2, |
| 5683 | MultiEntrySet = 1 << 3, |
| 5684 | AllFieldsSet = (NameSet | KeyPathSet | UniqueSet | MultiEntrySet) |
| 5685 | }; |
| 5686 | |
| 5687 | template<int STATE> |
| 5688 | class Builder { |
| 5689 | private: |
| 5690 | RefPtr<JSON::Object> m_result; |
| 5691 | |
| 5692 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5693 | { |
| 5694 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5695 | } |
| 5696 | |
| 5697 | Builder(Ref</*ObjectStoreIndex*/JSON::Object>&& object) |
| 5698 | : m_result(WTFMove(object)) |
| 5699 | { |
| 5700 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5701 | } |
| 5702 | friend class ObjectStoreIndex; |
| 5703 | public: |
| 5704 | |
| 5705 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 5706 | { |
| 5707 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 5708 | m_result->setString("name"_s , in_name); |
| 5709 | return castState<NameSet>(); |
| 5710 | } |
| 5711 | |
| 5712 | Builder<STATE | KeyPathSet>& setKeyPath(Ref<Protocol::IndexedDB::KeyPath>&& in_keyPath) |
| 5713 | { |
| 5714 | COMPILE_ASSERT(!(STATE & KeyPathSet), property_keyPath_already_set); |
| 5715 | m_result->setObject("keyPath"_s , WTFMove(in_keyPath)); |
| 5716 | return castState<KeyPathSet>(); |
| 5717 | } |
| 5718 | |
| 5719 | Builder<STATE | UniqueSet>& setUnique(bool in_unique) |
| 5720 | { |
| 5721 | COMPILE_ASSERT(!(STATE & UniqueSet), property_unique_already_set); |
| 5722 | m_result->setBoolean("unique"_s , in_unique); |
| 5723 | return castState<UniqueSet>(); |
| 5724 | } |
| 5725 | |
| 5726 | Builder<STATE | MultiEntrySet>& setMultiEntry(bool in_multiEntry) |
| 5727 | { |
| 5728 | COMPILE_ASSERT(!(STATE & MultiEntrySet), property_multiEntry_already_set); |
| 5729 | m_result->setBoolean("multiEntry"_s , in_multiEntry); |
| 5730 | return castState<MultiEntrySet>(); |
| 5731 | } |
| 5732 | |
| 5733 | Ref<ObjectStoreIndex> release() |
| 5734 | { |
| 5735 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5736 | COMPILE_ASSERT(sizeof(ObjectStoreIndex) == sizeof(JSON::Object), cannot_cast); |
| 5737 | |
| 5738 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5739 | auto result = WTFMove(*reinterpret_cast<Ref<ObjectStoreIndex>*>(&jsonResult)); |
| 5740 | return result; |
| 5741 | } |
| 5742 | }; |
| 5743 | |
| 5744 | /* |
| 5745 | * Synthetic constructor: |
| 5746 | * Ref<ObjectStoreIndex> result = ObjectStoreIndex::create() |
| 5747 | * .setName(...) |
| 5748 | * .setKeyPath(...) |
| 5749 | * .setUnique(...) |
| 5750 | * .setMultiEntry(...) |
| 5751 | * .release(); |
| 5752 | */ |
| 5753 | static Builder<NoFieldsSet> create() |
| 5754 | { |
| 5755 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5756 | } |
| 5757 | }; |
| 5758 | |
| 5759 | /* Key. */ |
| 5760 | class Key final : public JSON::Object { |
| 5761 | public: |
| 5762 | // Named after property name 'type' while generating Key. |
| 5763 | enum class Type { |
| 5764 | Number = 132, |
| 5765 | String = 133, |
| 5766 | Date = 107, |
| 5767 | Array = 134, |
| 5768 | }; // enum class Type |
| 5769 | |
| 5770 | enum { |
| 5771 | NoFieldsSet = 0, |
| 5772 | TypeSet = 1 << 0, |
| 5773 | AllFieldsSet = (TypeSet) |
| 5774 | }; |
| 5775 | |
| 5776 | template<int STATE> |
| 5777 | class Builder { |
| 5778 | private: |
| 5779 | RefPtr<JSON::Object> m_result; |
| 5780 | |
| 5781 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5782 | { |
| 5783 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5784 | } |
| 5785 | |
| 5786 | Builder(Ref</*Key*/JSON::Object>&& object) |
| 5787 | : m_result(WTFMove(object)) |
| 5788 | { |
| 5789 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5790 | } |
| 5791 | friend class Key; |
| 5792 | public: |
| 5793 | |
| 5794 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 5795 | { |
| 5796 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 5797 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 5798 | return castState<TypeSet>(); |
| 5799 | } |
| 5800 | |
| 5801 | Ref<Key> release() |
| 5802 | { |
| 5803 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5804 | COMPILE_ASSERT(sizeof(Key) == sizeof(JSON::Object), cannot_cast); |
| 5805 | |
| 5806 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5807 | auto result = WTFMove(*reinterpret_cast<Ref<Key>*>(&jsonResult)); |
| 5808 | return result; |
| 5809 | } |
| 5810 | }; |
| 5811 | |
| 5812 | /* |
| 5813 | * Synthetic constructor: |
| 5814 | * Ref<Key> result = Key::create() |
| 5815 | * .setType(...) |
| 5816 | * .release(); |
| 5817 | */ |
| 5818 | static Builder<NoFieldsSet> create() |
| 5819 | { |
| 5820 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5821 | } |
| 5822 | |
| 5823 | void setNumber(double in_opt_number) |
| 5824 | { |
| 5825 | JSON::ObjectBase::setDouble("number"_s , in_opt_number); |
| 5826 | } |
| 5827 | |
| 5828 | void setString(const String& in_opt_string) |
| 5829 | { |
| 5830 | JSON::ObjectBase::setString("string"_s , in_opt_string); |
| 5831 | } |
| 5832 | |
| 5833 | void setDate(double in_opt_date) |
| 5834 | { |
| 5835 | JSON::ObjectBase::setDouble("date"_s , in_opt_date); |
| 5836 | } |
| 5837 | |
| 5838 | void setArray(Ref<JSON::ArrayOf<Protocol::IndexedDB::Key>>&& in_opt_array) |
| 5839 | { |
| 5840 | JSON::ObjectBase::setArray("array"_s , WTFMove(in_opt_array)); |
| 5841 | } |
| 5842 | |
| 5843 | // Property names for type generated as open. |
| 5844 | JS_EXPORT_PRIVATE static const ASCIILiteral typeKey; |
| 5845 | JS_EXPORT_PRIVATE static const ASCIILiteral numberKey; |
| 5846 | JS_EXPORT_PRIVATE static const ASCIILiteral stringKey; |
| 5847 | JS_EXPORT_PRIVATE static const ASCIILiteral dateKey; |
| 5848 | JS_EXPORT_PRIVATE static const ASCIILiteral arrayKey; |
| 5849 | }; |
| 5850 | |
| 5851 | /* Key range. */ |
| 5852 | class KeyRange final : public JSON::Object { |
| 5853 | public: |
| 5854 | enum { |
| 5855 | NoFieldsSet = 0, |
| 5856 | LowerOpenSet = 1 << 0, |
| 5857 | UpperOpenSet = 1 << 1, |
| 5858 | AllFieldsSet = (LowerOpenSet | UpperOpenSet) |
| 5859 | }; |
| 5860 | |
| 5861 | template<int STATE> |
| 5862 | class Builder { |
| 5863 | private: |
| 5864 | RefPtr<JSON::Object> m_result; |
| 5865 | |
| 5866 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5867 | { |
| 5868 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5869 | } |
| 5870 | |
| 5871 | Builder(Ref</*KeyRange*/JSON::Object>&& object) |
| 5872 | : m_result(WTFMove(object)) |
| 5873 | { |
| 5874 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5875 | } |
| 5876 | friend class KeyRange; |
| 5877 | public: |
| 5878 | |
| 5879 | Builder<STATE | LowerOpenSet>& setLowerOpen(bool in_lowerOpen) |
| 5880 | { |
| 5881 | COMPILE_ASSERT(!(STATE & LowerOpenSet), property_lowerOpen_already_set); |
| 5882 | m_result->setBoolean("lowerOpen"_s , in_lowerOpen); |
| 5883 | return castState<LowerOpenSet>(); |
| 5884 | } |
| 5885 | |
| 5886 | Builder<STATE | UpperOpenSet>& setUpperOpen(bool in_upperOpen) |
| 5887 | { |
| 5888 | COMPILE_ASSERT(!(STATE & UpperOpenSet), property_upperOpen_already_set); |
| 5889 | m_result->setBoolean("upperOpen"_s , in_upperOpen); |
| 5890 | return castState<UpperOpenSet>(); |
| 5891 | } |
| 5892 | |
| 5893 | Ref<KeyRange> release() |
| 5894 | { |
| 5895 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5896 | COMPILE_ASSERT(sizeof(KeyRange) == sizeof(JSON::Object), cannot_cast); |
| 5897 | |
| 5898 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5899 | auto result = WTFMove(*reinterpret_cast<Ref<KeyRange>*>(&jsonResult)); |
| 5900 | return result; |
| 5901 | } |
| 5902 | }; |
| 5903 | |
| 5904 | /* |
| 5905 | * Synthetic constructor: |
| 5906 | * Ref<KeyRange> result = KeyRange::create() |
| 5907 | * .setLowerOpen(...) |
| 5908 | * .setUpperOpen(...) |
| 5909 | * .release(); |
| 5910 | */ |
| 5911 | static Builder<NoFieldsSet> create() |
| 5912 | { |
| 5913 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 5914 | } |
| 5915 | |
| 5916 | void setLower(Ref<Protocol::IndexedDB::Key>&& in_opt_lower) |
| 5917 | { |
| 5918 | JSON::ObjectBase::setObject("lower"_s , WTFMove(in_opt_lower)); |
| 5919 | } |
| 5920 | |
| 5921 | void setUpper(Ref<Protocol::IndexedDB::Key>&& in_opt_upper) |
| 5922 | { |
| 5923 | JSON::ObjectBase::setObject("upper"_s , WTFMove(in_opt_upper)); |
| 5924 | } |
| 5925 | |
| 5926 | // Property names for type generated as open. |
| 5927 | JS_EXPORT_PRIVATE static const ASCIILiteral lowerKey; |
| 5928 | JS_EXPORT_PRIVATE static const ASCIILiteral upperKey; |
| 5929 | JS_EXPORT_PRIVATE static const ASCIILiteral lowerOpenKey; |
| 5930 | JS_EXPORT_PRIVATE static const ASCIILiteral upperOpenKey; |
| 5931 | }; |
| 5932 | |
| 5933 | /* Data entry. */ |
| 5934 | class DataEntry final : public JSON::ObjectBase { |
| 5935 | public: |
| 5936 | enum { |
| 5937 | NoFieldsSet = 0, |
| 5938 | KeySet = 1 << 0, |
| 5939 | PrimaryKeySet = 1 << 1, |
| 5940 | ValueSet = 1 << 2, |
| 5941 | AllFieldsSet = (KeySet | PrimaryKeySet | ValueSet) |
| 5942 | }; |
| 5943 | |
| 5944 | template<int STATE> |
| 5945 | class Builder { |
| 5946 | private: |
| 5947 | RefPtr<JSON::Object> m_result; |
| 5948 | |
| 5949 | template<int STEP> Builder<STATE | STEP>& castState() |
| 5950 | { |
| 5951 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 5952 | } |
| 5953 | |
| 5954 | Builder(Ref</*DataEntry*/JSON::Object>&& object) |
| 5955 | : m_result(WTFMove(object)) |
| 5956 | { |
| 5957 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 5958 | } |
| 5959 | friend class DataEntry; |
| 5960 | public: |
| 5961 | |
| 5962 | Builder<STATE | KeySet>& setKey(Ref<Protocol::Runtime::RemoteObject>&& in_key) |
| 5963 | { |
| 5964 | COMPILE_ASSERT(!(STATE & KeySet), property_key_already_set); |
| 5965 | m_result->setObject("key"_s , WTFMove(in_key)); |
| 5966 | return castState<KeySet>(); |
| 5967 | } |
| 5968 | |
| 5969 | Builder<STATE | PrimaryKeySet>& setPrimaryKey(Ref<Protocol::Runtime::RemoteObject>&& in_primaryKey) |
| 5970 | { |
| 5971 | COMPILE_ASSERT(!(STATE & PrimaryKeySet), property_primaryKey_already_set); |
| 5972 | m_result->setObject("primaryKey"_s , WTFMove(in_primaryKey)); |
| 5973 | return castState<PrimaryKeySet>(); |
| 5974 | } |
| 5975 | |
| 5976 | Builder<STATE | ValueSet>& setValue(Ref<Protocol::Runtime::RemoteObject>&& in_value) |
| 5977 | { |
| 5978 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 5979 | m_result->setObject("value"_s , WTFMove(in_value)); |
| 5980 | return castState<ValueSet>(); |
| 5981 | } |
| 5982 | |
| 5983 | Ref<DataEntry> release() |
| 5984 | { |
| 5985 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 5986 | COMPILE_ASSERT(sizeof(DataEntry) == sizeof(JSON::Object), cannot_cast); |
| 5987 | |
| 5988 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 5989 | auto result = WTFMove(*reinterpret_cast<Ref<DataEntry>*>(&jsonResult)); |
| 5990 | return result; |
| 5991 | } |
| 5992 | }; |
| 5993 | |
| 5994 | /* |
| 5995 | * Synthetic constructor: |
| 5996 | * Ref<DataEntry> result = DataEntry::create() |
| 5997 | * .setKey(...) |
| 5998 | * .setPrimaryKey(...) |
| 5999 | * .setValue(...) |
| 6000 | * .release(); |
| 6001 | */ |
| 6002 | static Builder<NoFieldsSet> create() |
| 6003 | { |
| 6004 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6005 | } |
| 6006 | }; |
| 6007 | |
| 6008 | /* Key path. */ |
| 6009 | class KeyPath final : public JSON::ObjectBase { |
| 6010 | public: |
| 6011 | // Named after property name 'type' while generating KeyPath. |
| 6012 | enum class Type { |
| 6013 | Null = 135, |
| 6014 | String = 133, |
| 6015 | Array = 134, |
| 6016 | }; // enum class Type |
| 6017 | |
| 6018 | enum { |
| 6019 | NoFieldsSet = 0, |
| 6020 | TypeSet = 1 << 0, |
| 6021 | AllFieldsSet = (TypeSet) |
| 6022 | }; |
| 6023 | |
| 6024 | template<int STATE> |
| 6025 | class Builder { |
| 6026 | private: |
| 6027 | RefPtr<JSON::Object> m_result; |
| 6028 | |
| 6029 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6030 | { |
| 6031 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6032 | } |
| 6033 | |
| 6034 | Builder(Ref</*KeyPath*/JSON::Object>&& object) |
| 6035 | : m_result(WTFMove(object)) |
| 6036 | { |
| 6037 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6038 | } |
| 6039 | friend class KeyPath; |
| 6040 | public: |
| 6041 | |
| 6042 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 6043 | { |
| 6044 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 6045 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 6046 | return castState<TypeSet>(); |
| 6047 | } |
| 6048 | |
| 6049 | Ref<KeyPath> release() |
| 6050 | { |
| 6051 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6052 | COMPILE_ASSERT(sizeof(KeyPath) == sizeof(JSON::Object), cannot_cast); |
| 6053 | |
| 6054 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6055 | auto result = WTFMove(*reinterpret_cast<Ref<KeyPath>*>(&jsonResult)); |
| 6056 | return result; |
| 6057 | } |
| 6058 | }; |
| 6059 | |
| 6060 | /* |
| 6061 | * Synthetic constructor: |
| 6062 | * Ref<KeyPath> result = KeyPath::create() |
| 6063 | * .setType(...) |
| 6064 | * .release(); |
| 6065 | */ |
| 6066 | static Builder<NoFieldsSet> create() |
| 6067 | { |
| 6068 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6069 | } |
| 6070 | |
| 6071 | void setString(const String& in_opt_string) |
| 6072 | { |
| 6073 | JSON::ObjectBase::setString("string"_s , in_opt_string); |
| 6074 | } |
| 6075 | |
| 6076 | void setArray(Ref<JSON::ArrayOf<String>>&& in_opt_array) |
| 6077 | { |
| 6078 | JSON::ObjectBase::setArray("array"_s , WTFMove(in_opt_array)); |
| 6079 | } |
| 6080 | }; |
| 6081 | |
| 6082 | } // IndexedDB |
| 6083 | |
| 6084 | namespace LayerTree { |
| 6085 | |
| 6086 | /* A rectangle. */ |
| 6087 | class IntRect final : public JSON::ObjectBase { |
| 6088 | public: |
| 6089 | enum { |
| 6090 | NoFieldsSet = 0, |
| 6091 | XSet = 1 << 0, |
| 6092 | YSet = 1 << 1, |
| 6093 | WidthSet = 1 << 2, |
| 6094 | HeightSet = 1 << 3, |
| 6095 | AllFieldsSet = (XSet | YSet | WidthSet | HeightSet) |
| 6096 | }; |
| 6097 | |
| 6098 | template<int STATE> |
| 6099 | class Builder { |
| 6100 | private: |
| 6101 | RefPtr<JSON::Object> m_result; |
| 6102 | |
| 6103 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6104 | { |
| 6105 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6106 | } |
| 6107 | |
| 6108 | Builder(Ref</*IntRect*/JSON::Object>&& object) |
| 6109 | : m_result(WTFMove(object)) |
| 6110 | { |
| 6111 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6112 | } |
| 6113 | friend class IntRect; |
| 6114 | public: |
| 6115 | |
| 6116 | Builder<STATE | XSet>& setX(int in_x) |
| 6117 | { |
| 6118 | COMPILE_ASSERT(!(STATE & XSet), property_x_already_set); |
| 6119 | m_result->setInteger("x"_s , in_x); |
| 6120 | return castState<XSet>(); |
| 6121 | } |
| 6122 | |
| 6123 | Builder<STATE | YSet>& setY(int in_y) |
| 6124 | { |
| 6125 | COMPILE_ASSERT(!(STATE & YSet), property_y_already_set); |
| 6126 | m_result->setInteger("y"_s , in_y); |
| 6127 | return castState<YSet>(); |
| 6128 | } |
| 6129 | |
| 6130 | Builder<STATE | WidthSet>& setWidth(int in_width) |
| 6131 | { |
| 6132 | COMPILE_ASSERT(!(STATE & WidthSet), property_width_already_set); |
| 6133 | m_result->setInteger("width"_s , in_width); |
| 6134 | return castState<WidthSet>(); |
| 6135 | } |
| 6136 | |
| 6137 | Builder<STATE | HeightSet>& setHeight(int in_height) |
| 6138 | { |
| 6139 | COMPILE_ASSERT(!(STATE & HeightSet), property_height_already_set); |
| 6140 | m_result->setInteger("height"_s , in_height); |
| 6141 | return castState<HeightSet>(); |
| 6142 | } |
| 6143 | |
| 6144 | Ref<IntRect> release() |
| 6145 | { |
| 6146 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6147 | COMPILE_ASSERT(sizeof(IntRect) == sizeof(JSON::Object), cannot_cast); |
| 6148 | |
| 6149 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6150 | auto result = WTFMove(*reinterpret_cast<Ref<IntRect>*>(&jsonResult)); |
| 6151 | return result; |
| 6152 | } |
| 6153 | }; |
| 6154 | |
| 6155 | /* |
| 6156 | * Synthetic constructor: |
| 6157 | * Ref<IntRect> result = IntRect::create() |
| 6158 | * .setX(...) |
| 6159 | * .setY(...) |
| 6160 | * .setWidth(...) |
| 6161 | * .setHeight(...) |
| 6162 | * .release(); |
| 6163 | */ |
| 6164 | static Builder<NoFieldsSet> create() |
| 6165 | { |
| 6166 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6167 | } |
| 6168 | }; |
| 6169 | |
| 6170 | /* Information about a compositing layer. */ |
| 6171 | class Layer final : public JSON::ObjectBase { |
| 6172 | public: |
| 6173 | enum { |
| 6174 | NoFieldsSet = 0, |
| 6175 | LayerIdSet = 1 << 0, |
| 6176 | NodeIdSet = 1 << 1, |
| 6177 | BoundsSet = 1 << 2, |
| 6178 | PaintCountSet = 1 << 3, |
| 6179 | MemorySet = 1 << 4, |
| 6180 | CompositedBoundsSet = 1 << 5, |
| 6181 | AllFieldsSet = (LayerIdSet | NodeIdSet | BoundsSet | PaintCountSet | MemorySet | CompositedBoundsSet) |
| 6182 | }; |
| 6183 | |
| 6184 | template<int STATE> |
| 6185 | class Builder { |
| 6186 | private: |
| 6187 | RefPtr<JSON::Object> m_result; |
| 6188 | |
| 6189 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6190 | { |
| 6191 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6192 | } |
| 6193 | |
| 6194 | Builder(Ref</*Layer*/JSON::Object>&& object) |
| 6195 | : m_result(WTFMove(object)) |
| 6196 | { |
| 6197 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6198 | } |
| 6199 | friend class Layer; |
| 6200 | public: |
| 6201 | |
| 6202 | Builder<STATE | LayerIdSet>& setLayerId(const String& in_layerId) |
| 6203 | { |
| 6204 | COMPILE_ASSERT(!(STATE & LayerIdSet), property_layerId_already_set); |
| 6205 | m_result->setString("layerId"_s , in_layerId); |
| 6206 | return castState<LayerIdSet>(); |
| 6207 | } |
| 6208 | |
| 6209 | Builder<STATE | NodeIdSet>& setNodeId(int in_nodeId) |
| 6210 | { |
| 6211 | COMPILE_ASSERT(!(STATE & NodeIdSet), property_nodeId_already_set); |
| 6212 | m_result->setInteger("nodeId"_s , in_nodeId); |
| 6213 | return castState<NodeIdSet>(); |
| 6214 | } |
| 6215 | |
| 6216 | Builder<STATE | BoundsSet>& setBounds(Ref<Protocol::LayerTree::IntRect>&& in_bounds) |
| 6217 | { |
| 6218 | COMPILE_ASSERT(!(STATE & BoundsSet), property_bounds_already_set); |
| 6219 | m_result->setObject("bounds"_s , WTFMove(in_bounds)); |
| 6220 | return castState<BoundsSet>(); |
| 6221 | } |
| 6222 | |
| 6223 | Builder<STATE | PaintCountSet>& setPaintCount(int in_paintCount) |
| 6224 | { |
| 6225 | COMPILE_ASSERT(!(STATE & PaintCountSet), property_paintCount_already_set); |
| 6226 | m_result->setInteger("paintCount"_s , in_paintCount); |
| 6227 | return castState<PaintCountSet>(); |
| 6228 | } |
| 6229 | |
| 6230 | Builder<STATE | MemorySet>& setMemory(int in_memory) |
| 6231 | { |
| 6232 | COMPILE_ASSERT(!(STATE & MemorySet), property_memory_already_set); |
| 6233 | m_result->setInteger("memory"_s , in_memory); |
| 6234 | return castState<MemorySet>(); |
| 6235 | } |
| 6236 | |
| 6237 | Builder<STATE | CompositedBoundsSet>& setCompositedBounds(Ref<Protocol::LayerTree::IntRect>&& in_compositedBounds) |
| 6238 | { |
| 6239 | COMPILE_ASSERT(!(STATE & CompositedBoundsSet), property_compositedBounds_already_set); |
| 6240 | m_result->setObject("compositedBounds"_s , WTFMove(in_compositedBounds)); |
| 6241 | return castState<CompositedBoundsSet>(); |
| 6242 | } |
| 6243 | |
| 6244 | Ref<Layer> release() |
| 6245 | { |
| 6246 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6247 | COMPILE_ASSERT(sizeof(Layer) == sizeof(JSON::Object), cannot_cast); |
| 6248 | |
| 6249 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6250 | auto result = WTFMove(*reinterpret_cast<Ref<Layer>*>(&jsonResult)); |
| 6251 | return result; |
| 6252 | } |
| 6253 | }; |
| 6254 | |
| 6255 | /* |
| 6256 | * Synthetic constructor: |
| 6257 | * Ref<Layer> result = Layer::create() |
| 6258 | * .setLayerId(...) |
| 6259 | * .setNodeId(...) |
| 6260 | * .setBounds(...) |
| 6261 | * .setPaintCount(...) |
| 6262 | * .setMemory(...) |
| 6263 | * .setCompositedBounds(...) |
| 6264 | * .release(); |
| 6265 | */ |
| 6266 | static Builder<NoFieldsSet> create() |
| 6267 | { |
| 6268 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6269 | } |
| 6270 | |
| 6271 | void setIsInShadowTree(bool in_opt_isInShadowTree) |
| 6272 | { |
| 6273 | JSON::ObjectBase::setBoolean("isInShadowTree"_s , in_opt_isInShadowTree); |
| 6274 | } |
| 6275 | |
| 6276 | void setIsReflection(bool in_opt_isReflection) |
| 6277 | { |
| 6278 | JSON::ObjectBase::setBoolean("isReflection"_s , in_opt_isReflection); |
| 6279 | } |
| 6280 | |
| 6281 | void setIsGeneratedContent(bool in_opt_isGeneratedContent) |
| 6282 | { |
| 6283 | JSON::ObjectBase::setBoolean("isGeneratedContent"_s , in_opt_isGeneratedContent); |
| 6284 | } |
| 6285 | |
| 6286 | void setIsAnonymous(bool in_opt_isAnonymous) |
| 6287 | { |
| 6288 | JSON::ObjectBase::setBoolean("isAnonymous"_s , in_opt_isAnonymous); |
| 6289 | } |
| 6290 | |
| 6291 | void setPseudoElementId(const String& in_opt_pseudoElementId) |
| 6292 | { |
| 6293 | JSON::ObjectBase::setString("pseudoElementId"_s , in_opt_pseudoElementId); |
| 6294 | } |
| 6295 | |
| 6296 | void setPseudoElement(const String& in_opt_pseudoElement) |
| 6297 | { |
| 6298 | JSON::ObjectBase::setString("pseudoElement"_s , in_opt_pseudoElement); |
| 6299 | } |
| 6300 | }; |
| 6301 | |
| 6302 | /* An object containing the reasons why the layer was composited as properties. */ |
| 6303 | class CompositingReasons final : public JSON::ObjectBase { |
| 6304 | public: |
| 6305 | enum { |
| 6306 | NoFieldsSet = 0, |
| 6307 | AllFieldsSet = 0 |
| 6308 | }; |
| 6309 | |
| 6310 | template<int STATE> |
| 6311 | class Builder { |
| 6312 | private: |
| 6313 | RefPtr<JSON::Object> m_result; |
| 6314 | |
| 6315 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6316 | { |
| 6317 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6318 | } |
| 6319 | |
| 6320 | Builder(Ref</*CompositingReasons*/JSON::Object>&& object) |
| 6321 | : m_result(WTFMove(object)) |
| 6322 | { |
| 6323 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6324 | } |
| 6325 | friend class CompositingReasons; |
| 6326 | public: |
| 6327 | |
| 6328 | Ref<CompositingReasons> release() |
| 6329 | { |
| 6330 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6331 | COMPILE_ASSERT(sizeof(CompositingReasons) == sizeof(JSON::Object), cannot_cast); |
| 6332 | |
| 6333 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6334 | auto result = WTFMove(*reinterpret_cast<Ref<CompositingReasons>*>(&jsonResult)); |
| 6335 | return result; |
| 6336 | } |
| 6337 | }; |
| 6338 | |
| 6339 | /* |
| 6340 | * Synthetic constructor: |
| 6341 | * Ref<CompositingReasons> result = CompositingReasons::create() |
| 6342 | * .release(); |
| 6343 | */ |
| 6344 | static Builder<NoFieldsSet> create() |
| 6345 | { |
| 6346 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6347 | } |
| 6348 | |
| 6349 | void setTransform3D(bool in_opt_transform3D) |
| 6350 | { |
| 6351 | JSON::ObjectBase::setBoolean("transform3D"_s , in_opt_transform3D); |
| 6352 | } |
| 6353 | |
| 6354 | void setVideo(bool in_opt_video) |
| 6355 | { |
| 6356 | JSON::ObjectBase::setBoolean("video"_s , in_opt_video); |
| 6357 | } |
| 6358 | |
| 6359 | void setCanvas(bool in_opt_canvas) |
| 6360 | { |
| 6361 | JSON::ObjectBase::setBoolean("canvas"_s , in_opt_canvas); |
| 6362 | } |
| 6363 | |
| 6364 | void setPlugin(bool in_opt_plugin) |
| 6365 | { |
| 6366 | JSON::ObjectBase::setBoolean("plugin"_s , in_opt_plugin); |
| 6367 | } |
| 6368 | |
| 6369 | void setIFrame(bool in_opt_iFrame) |
| 6370 | { |
| 6371 | JSON::ObjectBase::setBoolean("iFrame"_s , in_opt_iFrame); |
| 6372 | } |
| 6373 | |
| 6374 | void setModel(bool in_opt_model) |
| 6375 | { |
| 6376 | JSON::ObjectBase::setBoolean("model"_s , in_opt_model); |
| 6377 | } |
| 6378 | |
| 6379 | void setBackfaceVisibilityHidden(bool in_opt_backfaceVisibilityHidden) |
| 6380 | { |
| 6381 | JSON::ObjectBase::setBoolean("backfaceVisibilityHidden"_s , in_opt_backfaceVisibilityHidden); |
| 6382 | } |
| 6383 | |
| 6384 | void setClipsCompositingDescendants(bool in_opt_clipsCompositingDescendants) |
| 6385 | { |
| 6386 | JSON::ObjectBase::setBoolean("clipsCompositingDescendants"_s , in_opt_clipsCompositingDescendants); |
| 6387 | } |
| 6388 | |
| 6389 | void setAnimation(bool in_opt_animation) |
| 6390 | { |
| 6391 | JSON::ObjectBase::setBoolean("animation"_s , in_opt_animation); |
| 6392 | } |
| 6393 | |
| 6394 | void setFilters(bool in_opt_filters) |
| 6395 | { |
| 6396 | JSON::ObjectBase::setBoolean("filters"_s , in_opt_filters); |
| 6397 | } |
| 6398 | |
| 6399 | void setPositionFixed(bool in_opt_positionFixed) |
| 6400 | { |
| 6401 | JSON::ObjectBase::setBoolean("positionFixed"_s , in_opt_positionFixed); |
| 6402 | } |
| 6403 | |
| 6404 | void setPositionSticky(bool in_opt_positionSticky) |
| 6405 | { |
| 6406 | JSON::ObjectBase::setBoolean("positionSticky"_s , in_opt_positionSticky); |
| 6407 | } |
| 6408 | |
| 6409 | void setOverflowScrollingTouch(bool in_opt_overflowScrollingTouch) |
| 6410 | { |
| 6411 | JSON::ObjectBase::setBoolean("overflowScrollingTouch"_s , in_opt_overflowScrollingTouch); |
| 6412 | } |
| 6413 | |
| 6414 | void setStacking(bool in_opt_stacking) |
| 6415 | { |
| 6416 | JSON::ObjectBase::setBoolean("stacking"_s , in_opt_stacking); |
| 6417 | } |
| 6418 | |
| 6419 | void setOverlap(bool in_opt_overlap) |
| 6420 | { |
| 6421 | JSON::ObjectBase::setBoolean("overlap"_s , in_opt_overlap); |
| 6422 | } |
| 6423 | |
| 6424 | void setNegativeZIndexChildren(bool in_opt_negativeZIndexChildren) |
| 6425 | { |
| 6426 | JSON::ObjectBase::setBoolean("negativeZIndexChildren"_s , in_opt_negativeZIndexChildren); |
| 6427 | } |
| 6428 | |
| 6429 | void setTransformWithCompositedDescendants(bool in_opt_transformWithCompositedDescendants) |
| 6430 | { |
| 6431 | JSON::ObjectBase::setBoolean("transformWithCompositedDescendants"_s , in_opt_transformWithCompositedDescendants); |
| 6432 | } |
| 6433 | |
| 6434 | void setOpacityWithCompositedDescendants(bool in_opt_opacityWithCompositedDescendants) |
| 6435 | { |
| 6436 | JSON::ObjectBase::setBoolean("opacityWithCompositedDescendants"_s , in_opt_opacityWithCompositedDescendants); |
| 6437 | } |
| 6438 | |
| 6439 | void setMaskWithCompositedDescendants(bool in_opt_maskWithCompositedDescendants) |
| 6440 | { |
| 6441 | JSON::ObjectBase::setBoolean("maskWithCompositedDescendants"_s , in_opt_maskWithCompositedDescendants); |
| 6442 | } |
| 6443 | |
| 6444 | void setReflectionWithCompositedDescendants(bool in_opt_reflectionWithCompositedDescendants) |
| 6445 | { |
| 6446 | JSON::ObjectBase::setBoolean("reflectionWithCompositedDescendants"_s , in_opt_reflectionWithCompositedDescendants); |
| 6447 | } |
| 6448 | |
| 6449 | void setFilterWithCompositedDescendants(bool in_opt_filterWithCompositedDescendants) |
| 6450 | { |
| 6451 | JSON::ObjectBase::setBoolean("filterWithCompositedDescendants"_s , in_opt_filterWithCompositedDescendants); |
| 6452 | } |
| 6453 | |
| 6454 | void setBlendingWithCompositedDescendants(bool in_opt_blendingWithCompositedDescendants) |
| 6455 | { |
| 6456 | JSON::ObjectBase::setBoolean("blendingWithCompositedDescendants"_s , in_opt_blendingWithCompositedDescendants); |
| 6457 | } |
| 6458 | |
| 6459 | void setIsolatesCompositedBlendingDescendants(bool in_opt_isolatesCompositedBlendingDescendants) |
| 6460 | { |
| 6461 | JSON::ObjectBase::setBoolean("isolatesCompositedBlendingDescendants"_s , in_opt_isolatesCompositedBlendingDescendants); |
| 6462 | } |
| 6463 | |
| 6464 | void setPerspective(bool in_opt_perspective) |
| 6465 | { |
| 6466 | JSON::ObjectBase::setBoolean("perspective"_s , in_opt_perspective); |
| 6467 | } |
| 6468 | |
| 6469 | void setPreserve3D(bool in_opt_preserve3D) |
| 6470 | { |
| 6471 | JSON::ObjectBase::setBoolean("preserve3D"_s , in_opt_preserve3D); |
| 6472 | } |
| 6473 | |
| 6474 | void setWillChange(bool in_opt_willChange) |
| 6475 | { |
| 6476 | JSON::ObjectBase::setBoolean("willChange"_s , in_opt_willChange); |
| 6477 | } |
| 6478 | |
| 6479 | void setRoot(bool in_opt_root) |
| 6480 | { |
| 6481 | JSON::ObjectBase::setBoolean("root"_s , in_opt_root); |
| 6482 | } |
| 6483 | |
| 6484 | void setBlending(bool in_opt_blending) |
| 6485 | { |
| 6486 | JSON::ObjectBase::setBoolean("blending"_s , in_opt_blending); |
| 6487 | } |
| 6488 | }; |
| 6489 | |
| 6490 | } // LayerTree |
| 6491 | |
| 6492 | #if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 6493 | namespace Memory { |
| 6494 | |
| 6495 | class Event final : public JSON::ObjectBase { |
| 6496 | public: |
| 6497 | enum { |
| 6498 | NoFieldsSet = 0, |
| 6499 | TimestampSet = 1 << 0, |
| 6500 | CategoriesSet = 1 << 1, |
| 6501 | AllFieldsSet = (TimestampSet | CategoriesSet) |
| 6502 | }; |
| 6503 | |
| 6504 | template<int STATE> |
| 6505 | class Builder { |
| 6506 | private: |
| 6507 | RefPtr<JSON::Object> m_result; |
| 6508 | |
| 6509 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6510 | { |
| 6511 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6512 | } |
| 6513 | |
| 6514 | Builder(Ref</*Event*/JSON::Object>&& object) |
| 6515 | : m_result(WTFMove(object)) |
| 6516 | { |
| 6517 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6518 | } |
| 6519 | friend class Event; |
| 6520 | public: |
| 6521 | |
| 6522 | Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp) |
| 6523 | { |
| 6524 | COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set); |
| 6525 | m_result->setDouble("timestamp"_s , in_timestamp); |
| 6526 | return castState<TimestampSet>(); |
| 6527 | } |
| 6528 | |
| 6529 | Builder<STATE | CategoriesSet>& setCategories(Ref<JSON::ArrayOf<Protocol::Memory::CategoryData>>&& in_categories) |
| 6530 | { |
| 6531 | COMPILE_ASSERT(!(STATE & CategoriesSet), property_categories_already_set); |
| 6532 | m_result->setArray("categories"_s , WTFMove(in_categories)); |
| 6533 | return castState<CategoriesSet>(); |
| 6534 | } |
| 6535 | |
| 6536 | Ref<Event> release() |
| 6537 | { |
| 6538 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6539 | COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast); |
| 6540 | |
| 6541 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6542 | auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult)); |
| 6543 | return result; |
| 6544 | } |
| 6545 | }; |
| 6546 | |
| 6547 | /* |
| 6548 | * Synthetic constructor: |
| 6549 | * Ref<Event> result = Event::create() |
| 6550 | * .setTimestamp(...) |
| 6551 | * .setCategories(...) |
| 6552 | * .release(); |
| 6553 | */ |
| 6554 | static Builder<NoFieldsSet> create() |
| 6555 | { |
| 6556 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6557 | } |
| 6558 | }; |
| 6559 | |
| 6560 | class CategoryData final : public JSON::ObjectBase { |
| 6561 | public: |
| 6562 | // Named after property name 'type' while generating CategoryData. |
| 6563 | enum class Type { |
| 6564 | JavaScript = 55, |
| 6565 | JIT = 136, |
| 6566 | Images = 137, |
| 6567 | Layers = 138, |
| 6568 | Page = 104, |
| 6569 | Other = 70, |
| 6570 | }; // enum class Type |
| 6571 | |
| 6572 | enum { |
| 6573 | NoFieldsSet = 0, |
| 6574 | TypeSet = 1 << 0, |
| 6575 | SizeSet = 1 << 1, |
| 6576 | AllFieldsSet = (TypeSet | SizeSet) |
| 6577 | }; |
| 6578 | |
| 6579 | template<int STATE> |
| 6580 | class Builder { |
| 6581 | private: |
| 6582 | RefPtr<JSON::Object> m_result; |
| 6583 | |
| 6584 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6585 | { |
| 6586 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6587 | } |
| 6588 | |
| 6589 | Builder(Ref</*CategoryData*/JSON::Object>&& object) |
| 6590 | : m_result(WTFMove(object)) |
| 6591 | { |
| 6592 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6593 | } |
| 6594 | friend class CategoryData; |
| 6595 | public: |
| 6596 | |
| 6597 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 6598 | { |
| 6599 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 6600 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 6601 | return castState<TypeSet>(); |
| 6602 | } |
| 6603 | |
| 6604 | Builder<STATE | SizeSet>& setSize(double in_size) |
| 6605 | { |
| 6606 | COMPILE_ASSERT(!(STATE & SizeSet), property_size_already_set); |
| 6607 | m_result->setDouble("size"_s , in_size); |
| 6608 | return castState<SizeSet>(); |
| 6609 | } |
| 6610 | |
| 6611 | Ref<CategoryData> release() |
| 6612 | { |
| 6613 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6614 | COMPILE_ASSERT(sizeof(CategoryData) == sizeof(JSON::Object), cannot_cast); |
| 6615 | |
| 6616 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6617 | auto result = WTFMove(*reinterpret_cast<Ref<CategoryData>*>(&jsonResult)); |
| 6618 | return result; |
| 6619 | } |
| 6620 | }; |
| 6621 | |
| 6622 | /* |
| 6623 | * Synthetic constructor: |
| 6624 | * Ref<CategoryData> result = CategoryData::create() |
| 6625 | * .setType(...) |
| 6626 | * .setSize(...) |
| 6627 | * .release(); |
| 6628 | */ |
| 6629 | static Builder<NoFieldsSet> create() |
| 6630 | { |
| 6631 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6632 | } |
| 6633 | }; |
| 6634 | |
| 6635 | } // Memory |
| 6636 | #endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 6637 | |
| 6638 | namespace Network { |
| 6639 | |
| 6640 | /* Request / response headers as keys / values of JSON object. */ |
| 6641 | class final : public JSON::ObjectBase { |
| 6642 | public: |
| 6643 | enum { |
| 6644 | = 0, |
| 6645 | = 0 |
| 6646 | }; |
| 6647 | |
| 6648 | template<int STATE> |
| 6649 | class { |
| 6650 | private: |
| 6651 | RefPtr<JSON::Object> ; |
| 6652 | |
| 6653 | template<int STEP> Builder<STATE | STEP>& () |
| 6654 | { |
| 6655 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6656 | } |
| 6657 | |
| 6658 | (Ref</*Headers*/JSON::Object>&& object) |
| 6659 | : m_result(WTFMove(object)) |
| 6660 | { |
| 6661 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6662 | } |
| 6663 | friend class Headers; |
| 6664 | public: |
| 6665 | |
| 6666 | Ref<Headers> () |
| 6667 | { |
| 6668 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6669 | COMPILE_ASSERT(sizeof(Headers) == sizeof(JSON::Object), cannot_cast); |
| 6670 | |
| 6671 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6672 | auto result = WTFMove(*reinterpret_cast<Ref<Headers>*>(&jsonResult)); |
| 6673 | return result; |
| 6674 | } |
| 6675 | }; |
| 6676 | |
| 6677 | /* |
| 6678 | * Synthetic constructor: |
| 6679 | * Ref<Headers> result = Headers::create() |
| 6680 | * .release(); |
| 6681 | */ |
| 6682 | static Builder<NoFieldsSet> () |
| 6683 | { |
| 6684 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6685 | } |
| 6686 | }; |
| 6687 | |
| 6688 | /* Timing information for the request. */ |
| 6689 | class ResourceTiming final : public JSON::ObjectBase { |
| 6690 | public: |
| 6691 | enum { |
| 6692 | NoFieldsSet = 0, |
| 6693 | StartTimeSet = 1 << 0, |
| 6694 | RedirectStartSet = 1 << 1, |
| 6695 | RedirectEndSet = 1 << 2, |
| 6696 | FetchStartSet = 1 << 3, |
| 6697 | DomainLookupStartSet = 1 << 4, |
| 6698 | DomainLookupEndSet = 1 << 5, |
| 6699 | ConnectStartSet = 1 << 6, |
| 6700 | ConnectEndSet = 1 << 7, |
| 6701 | SecureConnectionStartSet = 1 << 8, |
| 6702 | RequestStartSet = 1 << 9, |
| 6703 | ResponseStartSet = 1 << 10, |
| 6704 | ResponseEndSet = 1 << 11, |
| 6705 | AllFieldsSet = (StartTimeSet | RedirectStartSet | RedirectEndSet | FetchStartSet | DomainLookupStartSet | DomainLookupEndSet | ConnectStartSet | ConnectEndSet | SecureConnectionStartSet | RequestStartSet | ResponseStartSet | ResponseEndSet) |
| 6706 | }; |
| 6707 | |
| 6708 | template<int STATE> |
| 6709 | class Builder { |
| 6710 | private: |
| 6711 | RefPtr<JSON::Object> m_result; |
| 6712 | |
| 6713 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6714 | { |
| 6715 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6716 | } |
| 6717 | |
| 6718 | Builder(Ref</*ResourceTiming*/JSON::Object>&& object) |
| 6719 | : m_result(WTFMove(object)) |
| 6720 | { |
| 6721 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6722 | } |
| 6723 | friend class ResourceTiming; |
| 6724 | public: |
| 6725 | |
| 6726 | Builder<STATE | StartTimeSet>& setStartTime(double in_startTime) |
| 6727 | { |
| 6728 | COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set); |
| 6729 | m_result->setDouble("startTime"_s , in_startTime); |
| 6730 | return castState<StartTimeSet>(); |
| 6731 | } |
| 6732 | |
| 6733 | Builder<STATE | RedirectStartSet>& setRedirectStart(double in_redirectStart) |
| 6734 | { |
| 6735 | COMPILE_ASSERT(!(STATE & RedirectStartSet), property_redirectStart_already_set); |
| 6736 | m_result->setDouble("redirectStart"_s , in_redirectStart); |
| 6737 | return castState<RedirectStartSet>(); |
| 6738 | } |
| 6739 | |
| 6740 | Builder<STATE | RedirectEndSet>& setRedirectEnd(double in_redirectEnd) |
| 6741 | { |
| 6742 | COMPILE_ASSERT(!(STATE & RedirectEndSet), property_redirectEnd_already_set); |
| 6743 | m_result->setDouble("redirectEnd"_s , in_redirectEnd); |
| 6744 | return castState<RedirectEndSet>(); |
| 6745 | } |
| 6746 | |
| 6747 | Builder<STATE | FetchStartSet>& setFetchStart(double in_fetchStart) |
| 6748 | { |
| 6749 | COMPILE_ASSERT(!(STATE & FetchStartSet), property_fetchStart_already_set); |
| 6750 | m_result->setDouble("fetchStart"_s , in_fetchStart); |
| 6751 | return castState<FetchStartSet>(); |
| 6752 | } |
| 6753 | |
| 6754 | Builder<STATE | DomainLookupStartSet>& setDomainLookupStart(double in_domainLookupStart) |
| 6755 | { |
| 6756 | COMPILE_ASSERT(!(STATE & DomainLookupStartSet), property_domainLookupStart_already_set); |
| 6757 | m_result->setDouble("domainLookupStart"_s , in_domainLookupStart); |
| 6758 | return castState<DomainLookupStartSet>(); |
| 6759 | } |
| 6760 | |
| 6761 | Builder<STATE | DomainLookupEndSet>& setDomainLookupEnd(double in_domainLookupEnd) |
| 6762 | { |
| 6763 | COMPILE_ASSERT(!(STATE & DomainLookupEndSet), property_domainLookupEnd_already_set); |
| 6764 | m_result->setDouble("domainLookupEnd"_s , in_domainLookupEnd); |
| 6765 | return castState<DomainLookupEndSet>(); |
| 6766 | } |
| 6767 | |
| 6768 | Builder<STATE | ConnectStartSet>& setConnectStart(double in_connectStart) |
| 6769 | { |
| 6770 | COMPILE_ASSERT(!(STATE & ConnectStartSet), property_connectStart_already_set); |
| 6771 | m_result->setDouble("connectStart"_s , in_connectStart); |
| 6772 | return castState<ConnectStartSet>(); |
| 6773 | } |
| 6774 | |
| 6775 | Builder<STATE | ConnectEndSet>& setConnectEnd(double in_connectEnd) |
| 6776 | { |
| 6777 | COMPILE_ASSERT(!(STATE & ConnectEndSet), property_connectEnd_already_set); |
| 6778 | m_result->setDouble("connectEnd"_s , in_connectEnd); |
| 6779 | return castState<ConnectEndSet>(); |
| 6780 | } |
| 6781 | |
| 6782 | Builder<STATE | SecureConnectionStartSet>& setSecureConnectionStart(double in_secureConnectionStart) |
| 6783 | { |
| 6784 | COMPILE_ASSERT(!(STATE & SecureConnectionStartSet), property_secureConnectionStart_already_set); |
| 6785 | m_result->setDouble("secureConnectionStart"_s , in_secureConnectionStart); |
| 6786 | return castState<SecureConnectionStartSet>(); |
| 6787 | } |
| 6788 | |
| 6789 | Builder<STATE | RequestStartSet>& setRequestStart(double in_requestStart) |
| 6790 | { |
| 6791 | COMPILE_ASSERT(!(STATE & RequestStartSet), property_requestStart_already_set); |
| 6792 | m_result->setDouble("requestStart"_s , in_requestStart); |
| 6793 | return castState<RequestStartSet>(); |
| 6794 | } |
| 6795 | |
| 6796 | Builder<STATE | ResponseStartSet>& setResponseStart(double in_responseStart) |
| 6797 | { |
| 6798 | COMPILE_ASSERT(!(STATE & ResponseStartSet), property_responseStart_already_set); |
| 6799 | m_result->setDouble("responseStart"_s , in_responseStart); |
| 6800 | return castState<ResponseStartSet>(); |
| 6801 | } |
| 6802 | |
| 6803 | Builder<STATE | ResponseEndSet>& setResponseEnd(double in_responseEnd) |
| 6804 | { |
| 6805 | COMPILE_ASSERT(!(STATE & ResponseEndSet), property_responseEnd_already_set); |
| 6806 | m_result->setDouble("responseEnd"_s , in_responseEnd); |
| 6807 | return castState<ResponseEndSet>(); |
| 6808 | } |
| 6809 | |
| 6810 | Ref<ResourceTiming> release() |
| 6811 | { |
| 6812 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6813 | COMPILE_ASSERT(sizeof(ResourceTiming) == sizeof(JSON::Object), cannot_cast); |
| 6814 | |
| 6815 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6816 | auto result = WTFMove(*reinterpret_cast<Ref<ResourceTiming>*>(&jsonResult)); |
| 6817 | return result; |
| 6818 | } |
| 6819 | }; |
| 6820 | |
| 6821 | /* |
| 6822 | * Synthetic constructor: |
| 6823 | * Ref<ResourceTiming> result = ResourceTiming::create() |
| 6824 | * .setStartTime(...) |
| 6825 | * .setRedirectStart(...) |
| 6826 | * .setRedirectEnd(...) |
| 6827 | * .setFetchStart(...) |
| 6828 | * .setDomainLookupStart(...) |
| 6829 | * .setDomainLookupEnd(...) |
| 6830 | * .setConnectStart(...) |
| 6831 | * .setConnectEnd(...) |
| 6832 | * .setSecureConnectionStart(...) |
| 6833 | * .setRequestStart(...) |
| 6834 | * .setResponseStart(...) |
| 6835 | * .setResponseEnd(...) |
| 6836 | * .release(); |
| 6837 | */ |
| 6838 | static Builder<NoFieldsSet> create() |
| 6839 | { |
| 6840 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6841 | } |
| 6842 | }; |
| 6843 | |
| 6844 | /* HTTP request data. */ |
| 6845 | class Request final : public JSON::ObjectBase { |
| 6846 | public: |
| 6847 | enum { |
| 6848 | NoFieldsSet = 0, |
| 6849 | UrlSet = 1 << 0, |
| 6850 | MethodSet = 1 << 1, |
| 6851 | = 1 << 2, |
| 6852 | AllFieldsSet = (UrlSet | MethodSet | HeadersSet) |
| 6853 | }; |
| 6854 | |
| 6855 | template<int STATE> |
| 6856 | class Builder { |
| 6857 | private: |
| 6858 | RefPtr<JSON::Object> m_result; |
| 6859 | |
| 6860 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6861 | { |
| 6862 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6863 | } |
| 6864 | |
| 6865 | Builder(Ref</*Request*/JSON::Object>&& object) |
| 6866 | : m_result(WTFMove(object)) |
| 6867 | { |
| 6868 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6869 | } |
| 6870 | friend class Request; |
| 6871 | public: |
| 6872 | |
| 6873 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 6874 | { |
| 6875 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 6876 | m_result->setString("url"_s , in_url); |
| 6877 | return castState<UrlSet>(); |
| 6878 | } |
| 6879 | |
| 6880 | Builder<STATE | MethodSet>& setMethod(const String& in_method) |
| 6881 | { |
| 6882 | COMPILE_ASSERT(!(STATE & MethodSet), property_method_already_set); |
| 6883 | m_result->setString("method"_s , in_method); |
| 6884 | return castState<MethodSet>(); |
| 6885 | } |
| 6886 | |
| 6887 | Builder<STATE | HeadersSet>& (Ref<Protocol::Network::Headers>&& ) |
| 6888 | { |
| 6889 | COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set); |
| 6890 | m_result->setObject("headers"_s , WTFMove(in_headers)); |
| 6891 | return castState<HeadersSet>(); |
| 6892 | } |
| 6893 | |
| 6894 | Ref<Request> release() |
| 6895 | { |
| 6896 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 6897 | COMPILE_ASSERT(sizeof(Request) == sizeof(JSON::Object), cannot_cast); |
| 6898 | |
| 6899 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 6900 | auto result = WTFMove(*reinterpret_cast<Ref<Request>*>(&jsonResult)); |
| 6901 | return result; |
| 6902 | } |
| 6903 | }; |
| 6904 | |
| 6905 | /* |
| 6906 | * Synthetic constructor: |
| 6907 | * Ref<Request> result = Request::create() |
| 6908 | * .setUrl(...) |
| 6909 | * .setMethod(...) |
| 6910 | * .setHeaders(...) |
| 6911 | * .release(); |
| 6912 | */ |
| 6913 | static Builder<NoFieldsSet> create() |
| 6914 | { |
| 6915 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 6916 | } |
| 6917 | |
| 6918 | void setPostData(const String& in_opt_postData) |
| 6919 | { |
| 6920 | JSON::ObjectBase::setString("postData"_s , in_opt_postData); |
| 6921 | } |
| 6922 | }; |
| 6923 | |
| 6924 | /* HTTP response data. */ |
| 6925 | class Response final : public JSON::Object { |
| 6926 | public: |
| 6927 | // Named after property name 'source' while generating Response. |
| 6928 | enum class Source { |
| 6929 | Unknown = 139, |
| 6930 | Network = 56, |
| 6931 | MemoryCache = 140, |
| 6932 | DiskCache = 141, |
| 6933 | ServiceWorker = 142, |
| 6934 | InspectorOverride = 143, |
| 6935 | }; // enum class Source |
| 6936 | |
| 6937 | enum { |
| 6938 | NoFieldsSet = 0, |
| 6939 | UrlSet = 1 << 0, |
| 6940 | StatusSet = 1 << 1, |
| 6941 | StatusTextSet = 1 << 2, |
| 6942 | = 1 << 3, |
| 6943 | MimeTypeSet = 1 << 4, |
| 6944 | SourceSet = 1 << 5, |
| 6945 | AllFieldsSet = (UrlSet | StatusSet | StatusTextSet | HeadersSet | MimeTypeSet | SourceSet) |
| 6946 | }; |
| 6947 | |
| 6948 | template<int STATE> |
| 6949 | class Builder { |
| 6950 | private: |
| 6951 | RefPtr<JSON::Object> m_result; |
| 6952 | |
| 6953 | template<int STEP> Builder<STATE | STEP>& castState() |
| 6954 | { |
| 6955 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 6956 | } |
| 6957 | |
| 6958 | Builder(Ref</*Response*/JSON::Object>&& object) |
| 6959 | : m_result(WTFMove(object)) |
| 6960 | { |
| 6961 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 6962 | } |
| 6963 | friend class Response; |
| 6964 | public: |
| 6965 | |
| 6966 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 6967 | { |
| 6968 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 6969 | m_result->setString("url"_s , in_url); |
| 6970 | return castState<UrlSet>(); |
| 6971 | } |
| 6972 | |
| 6973 | Builder<STATE | StatusSet>& setStatus(int in_status) |
| 6974 | { |
| 6975 | COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set); |
| 6976 | m_result->setInteger("status"_s , in_status); |
| 6977 | return castState<StatusSet>(); |
| 6978 | } |
| 6979 | |
| 6980 | Builder<STATE | StatusTextSet>& setStatusText(const String& in_statusText) |
| 6981 | { |
| 6982 | COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set); |
| 6983 | m_result->setString("statusText"_s , in_statusText); |
| 6984 | return castState<StatusTextSet>(); |
| 6985 | } |
| 6986 | |
| 6987 | Builder<STATE | HeadersSet>& (Ref<Protocol::Network::Headers>&& ) |
| 6988 | { |
| 6989 | COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set); |
| 6990 | m_result->setObject("headers"_s , WTFMove(in_headers)); |
| 6991 | return castState<HeadersSet>(); |
| 6992 | } |
| 6993 | |
| 6994 | Builder<STATE | MimeTypeSet>& setMimeType(const String& in_mimeType) |
| 6995 | { |
| 6996 | COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set); |
| 6997 | m_result->setString("mimeType"_s , in_mimeType); |
| 6998 | return castState<MimeTypeSet>(); |
| 6999 | } |
| 7000 | |
| 7001 | Builder<STATE | SourceSet>& setSource(Source in_source) |
| 7002 | { |
| 7003 | COMPILE_ASSERT(!(STATE & SourceSet), property_source_already_set); |
| 7004 | m_result->setString("source"_s , Protocol::Helpers::getEnumConstantValue(in_source)); |
| 7005 | return castState<SourceSet>(); |
| 7006 | } |
| 7007 | |
| 7008 | Ref<Response> release() |
| 7009 | { |
| 7010 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7011 | COMPILE_ASSERT(sizeof(Response) == sizeof(JSON::Object), cannot_cast); |
| 7012 | |
| 7013 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7014 | auto result = WTFMove(*reinterpret_cast<Ref<Response>*>(&jsonResult)); |
| 7015 | return result; |
| 7016 | } |
| 7017 | }; |
| 7018 | |
| 7019 | /* |
| 7020 | * Synthetic constructor: |
| 7021 | * Ref<Response> result = Response::create() |
| 7022 | * .setUrl(...) |
| 7023 | * .setStatus(...) |
| 7024 | * .setStatusText(...) |
| 7025 | * .setHeaders(...) |
| 7026 | * .setMimeType(...) |
| 7027 | * .setSource(...) |
| 7028 | * .release(); |
| 7029 | */ |
| 7030 | static Builder<NoFieldsSet> create() |
| 7031 | { |
| 7032 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7033 | } |
| 7034 | |
| 7035 | void (Ref<Protocol::Network::Headers>&& ) |
| 7036 | { |
| 7037 | JSON::ObjectBase::setObject("requestHeaders"_s , WTFMove(in_opt_requestHeaders)); |
| 7038 | } |
| 7039 | |
| 7040 | void setTiming(Ref<Protocol::Network::ResourceTiming>&& in_opt_timing) |
| 7041 | { |
| 7042 | JSON::ObjectBase::setObject("timing"_s , WTFMove(in_opt_timing)); |
| 7043 | } |
| 7044 | |
| 7045 | void setSecurity(Ref<Protocol::Security::Security>&& in_opt_security) |
| 7046 | { |
| 7047 | JSON::ObjectBase::setObject("security"_s , WTFMove(in_opt_security)); |
| 7048 | } |
| 7049 | |
| 7050 | // Property names for type generated as open. |
| 7051 | JS_EXPORT_PRIVATE static const ASCIILiteral statusKey; |
| 7052 | JS_EXPORT_PRIVATE static const ASCIILiteral statusTextKey; |
| 7053 | JS_EXPORT_PRIVATE static const ASCIILiteral mimeTypeKey; |
| 7054 | JS_EXPORT_PRIVATE static const ASCIILiteral sourceKey; |
| 7055 | }; |
| 7056 | |
| 7057 | /* Network load metrics. */ |
| 7058 | class Metrics final : public JSON::ObjectBase { |
| 7059 | public: |
| 7060 | // Named after property name 'priority' while generating Metrics. |
| 7061 | enum class Priority { |
| 7062 | Low = 144, |
| 7063 | Medium = 145, |
| 7064 | High = 146, |
| 7065 | }; // enum class Priority |
| 7066 | |
| 7067 | enum { |
| 7068 | NoFieldsSet = 0, |
| 7069 | AllFieldsSet = 0 |
| 7070 | }; |
| 7071 | |
| 7072 | template<int STATE> |
| 7073 | class Builder { |
| 7074 | private: |
| 7075 | RefPtr<JSON::Object> m_result; |
| 7076 | |
| 7077 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7078 | { |
| 7079 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7080 | } |
| 7081 | |
| 7082 | Builder(Ref</*Metrics*/JSON::Object>&& object) |
| 7083 | : m_result(WTFMove(object)) |
| 7084 | { |
| 7085 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7086 | } |
| 7087 | friend class Metrics; |
| 7088 | public: |
| 7089 | |
| 7090 | Ref<Metrics> release() |
| 7091 | { |
| 7092 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7093 | COMPILE_ASSERT(sizeof(Metrics) == sizeof(JSON::Object), cannot_cast); |
| 7094 | |
| 7095 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7096 | auto result = WTFMove(*reinterpret_cast<Ref<Metrics>*>(&jsonResult)); |
| 7097 | return result; |
| 7098 | } |
| 7099 | }; |
| 7100 | |
| 7101 | /* |
| 7102 | * Synthetic constructor: |
| 7103 | * Ref<Metrics> result = Metrics::create() |
| 7104 | * .release(); |
| 7105 | */ |
| 7106 | static Builder<NoFieldsSet> create() |
| 7107 | { |
| 7108 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7109 | } |
| 7110 | |
| 7111 | void setProtocol(const String& in_opt_protocol) |
| 7112 | { |
| 7113 | JSON::ObjectBase::setString("protocol"_s , in_opt_protocol); |
| 7114 | } |
| 7115 | |
| 7116 | void setPriority(Priority in_opt_priority) |
| 7117 | { |
| 7118 | JSON::ObjectBase::setString("priority"_s , Protocol::Helpers::getEnumConstantValue(in_opt_priority)); |
| 7119 | } |
| 7120 | |
| 7121 | void setConnectionIdentifier(const String& in_opt_connectionIdentifier) |
| 7122 | { |
| 7123 | JSON::ObjectBase::setString("connectionIdentifier"_s , in_opt_connectionIdentifier); |
| 7124 | } |
| 7125 | |
| 7126 | void setRemoteAddress(const String& in_opt_remoteAddress) |
| 7127 | { |
| 7128 | JSON::ObjectBase::setString("remoteAddress"_s , in_opt_remoteAddress); |
| 7129 | } |
| 7130 | |
| 7131 | void (Ref<Protocol::Network::Headers>&& ) |
| 7132 | { |
| 7133 | JSON::ObjectBase::setObject("requestHeaders"_s , WTFMove(in_opt_requestHeaders)); |
| 7134 | } |
| 7135 | |
| 7136 | void (double ) |
| 7137 | { |
| 7138 | JSON::ObjectBase::setDouble("requestHeaderBytesSent"_s , in_opt_requestHeaderBytesSent); |
| 7139 | } |
| 7140 | |
| 7141 | void setRequestBodyBytesSent(double in_opt_requestBodyBytesSent) |
| 7142 | { |
| 7143 | JSON::ObjectBase::setDouble("requestBodyBytesSent"_s , in_opt_requestBodyBytesSent); |
| 7144 | } |
| 7145 | |
| 7146 | void (double ) |
| 7147 | { |
| 7148 | JSON::ObjectBase::setDouble("responseHeaderBytesReceived"_s , in_opt_responseHeaderBytesReceived); |
| 7149 | } |
| 7150 | |
| 7151 | void setResponseBodyBytesReceived(double in_opt_responseBodyBytesReceived) |
| 7152 | { |
| 7153 | JSON::ObjectBase::setDouble("responseBodyBytesReceived"_s , in_opt_responseBodyBytesReceived); |
| 7154 | } |
| 7155 | |
| 7156 | void setResponseBodyDecodedSize(double in_opt_responseBodyDecodedSize) |
| 7157 | { |
| 7158 | JSON::ObjectBase::setDouble("responseBodyDecodedSize"_s , in_opt_responseBodyDecodedSize); |
| 7159 | } |
| 7160 | |
| 7161 | void setSecurityConnection(Ref<Protocol::Security::Connection>&& in_opt_securityConnection) |
| 7162 | { |
| 7163 | JSON::ObjectBase::setObject("securityConnection"_s , WTFMove(in_opt_securityConnection)); |
| 7164 | } |
| 7165 | }; |
| 7166 | |
| 7167 | /* WebSocket request data. */ |
| 7168 | class WebSocketRequest final : public JSON::ObjectBase { |
| 7169 | public: |
| 7170 | enum { |
| 7171 | NoFieldsSet = 0, |
| 7172 | = 1 << 0, |
| 7173 | AllFieldsSet = (HeadersSet) |
| 7174 | }; |
| 7175 | |
| 7176 | template<int STATE> |
| 7177 | class Builder { |
| 7178 | private: |
| 7179 | RefPtr<JSON::Object> m_result; |
| 7180 | |
| 7181 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7182 | { |
| 7183 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7184 | } |
| 7185 | |
| 7186 | Builder(Ref</*WebSocketRequest*/JSON::Object>&& object) |
| 7187 | : m_result(WTFMove(object)) |
| 7188 | { |
| 7189 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7190 | } |
| 7191 | friend class WebSocketRequest; |
| 7192 | public: |
| 7193 | |
| 7194 | Builder<STATE | HeadersSet>& (Ref<Protocol::Network::Headers>&& ) |
| 7195 | { |
| 7196 | COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set); |
| 7197 | m_result->setObject("headers"_s , WTFMove(in_headers)); |
| 7198 | return castState<HeadersSet>(); |
| 7199 | } |
| 7200 | |
| 7201 | Ref<WebSocketRequest> release() |
| 7202 | { |
| 7203 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7204 | COMPILE_ASSERT(sizeof(WebSocketRequest) == sizeof(JSON::Object), cannot_cast); |
| 7205 | |
| 7206 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7207 | auto result = WTFMove(*reinterpret_cast<Ref<WebSocketRequest>*>(&jsonResult)); |
| 7208 | return result; |
| 7209 | } |
| 7210 | }; |
| 7211 | |
| 7212 | /* |
| 7213 | * Synthetic constructor: |
| 7214 | * Ref<WebSocketRequest> result = WebSocketRequest::create() |
| 7215 | * .setHeaders(...) |
| 7216 | * .release(); |
| 7217 | */ |
| 7218 | static Builder<NoFieldsSet> create() |
| 7219 | { |
| 7220 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7221 | } |
| 7222 | }; |
| 7223 | |
| 7224 | /* WebSocket response data. */ |
| 7225 | class WebSocketResponse final : public JSON::ObjectBase { |
| 7226 | public: |
| 7227 | enum { |
| 7228 | NoFieldsSet = 0, |
| 7229 | StatusSet = 1 << 0, |
| 7230 | StatusTextSet = 1 << 1, |
| 7231 | = 1 << 2, |
| 7232 | AllFieldsSet = (StatusSet | StatusTextSet | HeadersSet) |
| 7233 | }; |
| 7234 | |
| 7235 | template<int STATE> |
| 7236 | class Builder { |
| 7237 | private: |
| 7238 | RefPtr<JSON::Object> m_result; |
| 7239 | |
| 7240 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7241 | { |
| 7242 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7243 | } |
| 7244 | |
| 7245 | Builder(Ref</*WebSocketResponse*/JSON::Object>&& object) |
| 7246 | : m_result(WTFMove(object)) |
| 7247 | { |
| 7248 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7249 | } |
| 7250 | friend class WebSocketResponse; |
| 7251 | public: |
| 7252 | |
| 7253 | Builder<STATE | StatusSet>& setStatus(int in_status) |
| 7254 | { |
| 7255 | COMPILE_ASSERT(!(STATE & StatusSet), property_status_already_set); |
| 7256 | m_result->setInteger("status"_s , in_status); |
| 7257 | return castState<StatusSet>(); |
| 7258 | } |
| 7259 | |
| 7260 | Builder<STATE | StatusTextSet>& setStatusText(const String& in_statusText) |
| 7261 | { |
| 7262 | COMPILE_ASSERT(!(STATE & StatusTextSet), property_statusText_already_set); |
| 7263 | m_result->setString("statusText"_s , in_statusText); |
| 7264 | return castState<StatusTextSet>(); |
| 7265 | } |
| 7266 | |
| 7267 | Builder<STATE | HeadersSet>& (Ref<Protocol::Network::Headers>&& ) |
| 7268 | { |
| 7269 | COMPILE_ASSERT(!(STATE & HeadersSet), property_headers_already_set); |
| 7270 | m_result->setObject("headers"_s , WTFMove(in_headers)); |
| 7271 | return castState<HeadersSet>(); |
| 7272 | } |
| 7273 | |
| 7274 | Ref<WebSocketResponse> release() |
| 7275 | { |
| 7276 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7277 | COMPILE_ASSERT(sizeof(WebSocketResponse) == sizeof(JSON::Object), cannot_cast); |
| 7278 | |
| 7279 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7280 | auto result = WTFMove(*reinterpret_cast<Ref<WebSocketResponse>*>(&jsonResult)); |
| 7281 | return result; |
| 7282 | } |
| 7283 | }; |
| 7284 | |
| 7285 | /* |
| 7286 | * Synthetic constructor: |
| 7287 | * Ref<WebSocketResponse> result = WebSocketResponse::create() |
| 7288 | * .setStatus(...) |
| 7289 | * .setStatusText(...) |
| 7290 | * .setHeaders(...) |
| 7291 | * .release(); |
| 7292 | */ |
| 7293 | static Builder<NoFieldsSet> create() |
| 7294 | { |
| 7295 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7296 | } |
| 7297 | }; |
| 7298 | |
| 7299 | /* WebSocket frame data. */ |
| 7300 | class WebSocketFrame final : public JSON::ObjectBase { |
| 7301 | public: |
| 7302 | enum { |
| 7303 | NoFieldsSet = 0, |
| 7304 | OpcodeSet = 1 << 0, |
| 7305 | MaskSet = 1 << 1, |
| 7306 | PayloadDataSet = 1 << 2, |
| 7307 | PayloadLengthSet = 1 << 3, |
| 7308 | AllFieldsSet = (OpcodeSet | MaskSet | PayloadDataSet | PayloadLengthSet) |
| 7309 | }; |
| 7310 | |
| 7311 | template<int STATE> |
| 7312 | class Builder { |
| 7313 | private: |
| 7314 | RefPtr<JSON::Object> m_result; |
| 7315 | |
| 7316 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7317 | { |
| 7318 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7319 | } |
| 7320 | |
| 7321 | Builder(Ref</*WebSocketFrame*/JSON::Object>&& object) |
| 7322 | : m_result(WTFMove(object)) |
| 7323 | { |
| 7324 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7325 | } |
| 7326 | friend class WebSocketFrame; |
| 7327 | public: |
| 7328 | |
| 7329 | Builder<STATE | OpcodeSet>& setOpcode(double in_opcode) |
| 7330 | { |
| 7331 | COMPILE_ASSERT(!(STATE & OpcodeSet), property_opcode_already_set); |
| 7332 | m_result->setDouble("opcode"_s , in_opcode); |
| 7333 | return castState<OpcodeSet>(); |
| 7334 | } |
| 7335 | |
| 7336 | Builder<STATE | MaskSet>& setMask(bool in_mask) |
| 7337 | { |
| 7338 | COMPILE_ASSERT(!(STATE & MaskSet), property_mask_already_set); |
| 7339 | m_result->setBoolean("mask"_s , in_mask); |
| 7340 | return castState<MaskSet>(); |
| 7341 | } |
| 7342 | |
| 7343 | Builder<STATE | PayloadDataSet>& setPayloadData(const String& in_payloadData) |
| 7344 | { |
| 7345 | COMPILE_ASSERT(!(STATE & PayloadDataSet), property_payloadData_already_set); |
| 7346 | m_result->setString("payloadData"_s , in_payloadData); |
| 7347 | return castState<PayloadDataSet>(); |
| 7348 | } |
| 7349 | |
| 7350 | Builder<STATE | PayloadLengthSet>& setPayloadLength(double in_payloadLength) |
| 7351 | { |
| 7352 | COMPILE_ASSERT(!(STATE & PayloadLengthSet), property_payloadLength_already_set); |
| 7353 | m_result->setDouble("payloadLength"_s , in_payloadLength); |
| 7354 | return castState<PayloadLengthSet>(); |
| 7355 | } |
| 7356 | |
| 7357 | Ref<WebSocketFrame> release() |
| 7358 | { |
| 7359 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7360 | COMPILE_ASSERT(sizeof(WebSocketFrame) == sizeof(JSON::Object), cannot_cast); |
| 7361 | |
| 7362 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7363 | auto result = WTFMove(*reinterpret_cast<Ref<WebSocketFrame>*>(&jsonResult)); |
| 7364 | return result; |
| 7365 | } |
| 7366 | }; |
| 7367 | |
| 7368 | /* |
| 7369 | * Synthetic constructor: |
| 7370 | * Ref<WebSocketFrame> result = WebSocketFrame::create() |
| 7371 | * .setOpcode(...) |
| 7372 | * .setMask(...) |
| 7373 | * .setPayloadData(...) |
| 7374 | * .setPayloadLength(...) |
| 7375 | * .release(); |
| 7376 | */ |
| 7377 | static Builder<NoFieldsSet> create() |
| 7378 | { |
| 7379 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7380 | } |
| 7381 | }; |
| 7382 | |
| 7383 | /* Information about the cached resource. */ |
| 7384 | class CachedResource final : public JSON::ObjectBase { |
| 7385 | public: |
| 7386 | enum { |
| 7387 | NoFieldsSet = 0, |
| 7388 | UrlSet = 1 << 0, |
| 7389 | TypeSet = 1 << 1, |
| 7390 | BodySizeSet = 1 << 2, |
| 7391 | AllFieldsSet = (UrlSet | TypeSet | BodySizeSet) |
| 7392 | }; |
| 7393 | |
| 7394 | template<int STATE> |
| 7395 | class Builder { |
| 7396 | private: |
| 7397 | RefPtr<JSON::Object> m_result; |
| 7398 | |
| 7399 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7400 | { |
| 7401 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7402 | } |
| 7403 | |
| 7404 | Builder(Ref</*CachedResource*/JSON::Object>&& object) |
| 7405 | : m_result(WTFMove(object)) |
| 7406 | { |
| 7407 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7408 | } |
| 7409 | friend class CachedResource; |
| 7410 | public: |
| 7411 | |
| 7412 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 7413 | { |
| 7414 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 7415 | m_result->setString("url"_s , in_url); |
| 7416 | return castState<UrlSet>(); |
| 7417 | } |
| 7418 | |
| 7419 | Builder<STATE | TypeSet>& setType(Protocol::Page::ResourceType in_type) |
| 7420 | { |
| 7421 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 7422 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 7423 | return castState<TypeSet>(); |
| 7424 | } |
| 7425 | |
| 7426 | Builder<STATE | BodySizeSet>& setBodySize(double in_bodySize) |
| 7427 | { |
| 7428 | COMPILE_ASSERT(!(STATE & BodySizeSet), property_bodySize_already_set); |
| 7429 | m_result->setDouble("bodySize"_s , in_bodySize); |
| 7430 | return castState<BodySizeSet>(); |
| 7431 | } |
| 7432 | |
| 7433 | Ref<CachedResource> release() |
| 7434 | { |
| 7435 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7436 | COMPILE_ASSERT(sizeof(CachedResource) == sizeof(JSON::Object), cannot_cast); |
| 7437 | |
| 7438 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7439 | auto result = WTFMove(*reinterpret_cast<Ref<CachedResource>*>(&jsonResult)); |
| 7440 | return result; |
| 7441 | } |
| 7442 | }; |
| 7443 | |
| 7444 | /* |
| 7445 | * Synthetic constructor: |
| 7446 | * Ref<CachedResource> result = CachedResource::create() |
| 7447 | * .setUrl(...) |
| 7448 | * .setType(...) |
| 7449 | * .setBodySize(...) |
| 7450 | * .release(); |
| 7451 | */ |
| 7452 | static Builder<NoFieldsSet> create() |
| 7453 | { |
| 7454 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7455 | } |
| 7456 | |
| 7457 | void setResponse(Ref<Protocol::Network::Response>&& in_opt_response) |
| 7458 | { |
| 7459 | JSON::ObjectBase::setObject("response"_s , WTFMove(in_opt_response)); |
| 7460 | } |
| 7461 | |
| 7462 | void setSourceMapURL(const String& in_opt_sourceMapURL) |
| 7463 | { |
| 7464 | JSON::ObjectBase::setString("sourceMapURL"_s , in_opt_sourceMapURL); |
| 7465 | } |
| 7466 | }; |
| 7467 | |
| 7468 | /* Information about the request initiator. */ |
| 7469 | class Initiator final : public JSON::ObjectBase { |
| 7470 | public: |
| 7471 | // Named after property name 'type' while generating Initiator. |
| 7472 | enum class Type { |
| 7473 | Parser = 158, |
| 7474 | Script = 159, |
| 7475 | Other = 70, |
| 7476 | }; // enum class Type |
| 7477 | |
| 7478 | enum { |
| 7479 | NoFieldsSet = 0, |
| 7480 | TypeSet = 1 << 0, |
| 7481 | AllFieldsSet = (TypeSet) |
| 7482 | }; |
| 7483 | |
| 7484 | template<int STATE> |
| 7485 | class Builder { |
| 7486 | private: |
| 7487 | RefPtr<JSON::Object> m_result; |
| 7488 | |
| 7489 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7490 | { |
| 7491 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7492 | } |
| 7493 | |
| 7494 | Builder(Ref</*Initiator*/JSON::Object>&& object) |
| 7495 | : m_result(WTFMove(object)) |
| 7496 | { |
| 7497 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7498 | } |
| 7499 | friend class Initiator; |
| 7500 | public: |
| 7501 | |
| 7502 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 7503 | { |
| 7504 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 7505 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 7506 | return castState<TypeSet>(); |
| 7507 | } |
| 7508 | |
| 7509 | Ref<Initiator> release() |
| 7510 | { |
| 7511 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7512 | COMPILE_ASSERT(sizeof(Initiator) == sizeof(JSON::Object), cannot_cast); |
| 7513 | |
| 7514 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7515 | auto result = WTFMove(*reinterpret_cast<Ref<Initiator>*>(&jsonResult)); |
| 7516 | return result; |
| 7517 | } |
| 7518 | }; |
| 7519 | |
| 7520 | /* |
| 7521 | * Synthetic constructor: |
| 7522 | * Ref<Initiator> result = Initiator::create() |
| 7523 | * .setType(...) |
| 7524 | * .release(); |
| 7525 | */ |
| 7526 | static Builder<NoFieldsSet> create() |
| 7527 | { |
| 7528 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7529 | } |
| 7530 | |
| 7531 | void setStackTrace(Ref<JSON::ArrayOf<Protocol::Console::CallFrame>>&& in_opt_stackTrace) |
| 7532 | { |
| 7533 | JSON::ObjectBase::setArray("stackTrace"_s , WTFMove(in_opt_stackTrace)); |
| 7534 | } |
| 7535 | |
| 7536 | void setUrl(const String& in_opt_url) |
| 7537 | { |
| 7538 | JSON::ObjectBase::setString("url"_s , in_opt_url); |
| 7539 | } |
| 7540 | |
| 7541 | void setLineNumber(double in_opt_lineNumber) |
| 7542 | { |
| 7543 | JSON::ObjectBase::setDouble("lineNumber"_s , in_opt_lineNumber); |
| 7544 | } |
| 7545 | |
| 7546 | void setNodeId(int in_opt_nodeId) |
| 7547 | { |
| 7548 | JSON::ObjectBase::setInteger("nodeId"_s , in_opt_nodeId); |
| 7549 | } |
| 7550 | }; |
| 7551 | |
| 7552 | /* Different stages of a network request. */ |
| 7553 | enum class NetworkStage { |
| 7554 | Request = 160, |
| 7555 | Response = 161, |
| 7556 | }; // enum class NetworkStage |
| 7557 | |
| 7558 | /* Different stages of a network request. */ |
| 7559 | enum class ResourceErrorType { |
| 7560 | General = 162, |
| 7561 | AccessControl = 163, |
| 7562 | Cancellation = 164, |
| 7563 | Timeout = 165, |
| 7564 | }; // enum class ResourceErrorType |
| 7565 | |
| 7566 | } // Network |
| 7567 | |
| 7568 | namespace Page { |
| 7569 | |
| 7570 | /* List of settings able to be overridden by WebInspector. */ |
| 7571 | enum class Setting { |
| 7572 | PrivateClickMeasurementDebugModeEnabled = 166, |
| 7573 | AuthorAndUserStylesEnabled = 167, |
| 7574 | ICECandidateFilteringEnabled = 168, |
| 7575 | ITPDebugModeEnabled = 169, |
| 7576 | ImagesEnabled = 170, |
| 7577 | MediaCaptureRequiresSecureConnection = 171, |
| 7578 | MockCaptureDevicesEnabled = 172, |
| 7579 | NeedsSiteSpecificQuirks = 173, |
| 7580 | ScriptEnabled = 174, |
| 7581 | ShowDebugBorders = 175, |
| 7582 | ShowRepaintCounter = 176, |
| 7583 | WebRTCEncryptionEnabled = 177, |
| 7584 | WebSecurityEnabled = 178, |
| 7585 | }; // enum class Setting |
| 7586 | |
| 7587 | /* Resource type as it was perceived by the rendering engine. */ |
| 7588 | enum class ResourceType { |
| 7589 | Document = 147, |
| 7590 | StyleSheet = 148, |
| 7591 | Image = 149, |
| 7592 | Font = 150, |
| 7593 | Script = 151, |
| 7594 | XHR = 152, |
| 7595 | Fetch = 153, |
| 7596 | Ping = 154, |
| 7597 | Beacon = 155, |
| 7598 | WebSocket = 156, |
| 7599 | Other = 157, |
| 7600 | }; // enum class ResourceType |
| 7601 | |
| 7602 | /* Coordinate system used by supplied coordinates. */ |
| 7603 | enum class CoordinateSystem { |
| 7604 | Viewport = 179, |
| 7605 | Page = 180, |
| 7606 | }; // enum class CoordinateSystem |
| 7607 | |
| 7608 | /* Same-Site policy of a cookie. */ |
| 7609 | enum class CookieSameSitePolicy { |
| 7610 | None = 181, |
| 7611 | Lax = 182, |
| 7612 | Strict = 183, |
| 7613 | }; // enum class CookieSameSitePolicy |
| 7614 | |
| 7615 | #if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 7616 | /* Page appearance name. */ |
| 7617 | enum class Appearance { |
| 7618 | Light = 184, |
| 7619 | Dark = 185, |
| 7620 | }; // enum class Appearance |
| 7621 | #endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 7622 | |
| 7623 | /* Information about the Frame on the page. */ |
| 7624 | class Frame final : public JSON::ObjectBase { |
| 7625 | public: |
| 7626 | enum { |
| 7627 | NoFieldsSet = 0, |
| 7628 | IdSet = 1 << 0, |
| 7629 | LoaderIdSet = 1 << 1, |
| 7630 | UrlSet = 1 << 2, |
| 7631 | SecurityOriginSet = 1 << 3, |
| 7632 | MimeTypeSet = 1 << 4, |
| 7633 | AllFieldsSet = (IdSet | LoaderIdSet | UrlSet | SecurityOriginSet | MimeTypeSet) |
| 7634 | }; |
| 7635 | |
| 7636 | template<int STATE> |
| 7637 | class Builder { |
| 7638 | private: |
| 7639 | RefPtr<JSON::Object> m_result; |
| 7640 | |
| 7641 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7642 | { |
| 7643 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7644 | } |
| 7645 | |
| 7646 | Builder(Ref</*Frame*/JSON::Object>&& object) |
| 7647 | : m_result(WTFMove(object)) |
| 7648 | { |
| 7649 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7650 | } |
| 7651 | friend class Frame; |
| 7652 | public: |
| 7653 | |
| 7654 | Builder<STATE | IdSet>& setId(const String& in_id) |
| 7655 | { |
| 7656 | COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set); |
| 7657 | m_result->setString("id"_s , in_id); |
| 7658 | return castState<IdSet>(); |
| 7659 | } |
| 7660 | |
| 7661 | Builder<STATE | LoaderIdSet>& setLoaderId(const String& in_loaderId) |
| 7662 | { |
| 7663 | COMPILE_ASSERT(!(STATE & LoaderIdSet), property_loaderId_already_set); |
| 7664 | m_result->setString("loaderId"_s , in_loaderId); |
| 7665 | return castState<LoaderIdSet>(); |
| 7666 | } |
| 7667 | |
| 7668 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 7669 | { |
| 7670 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 7671 | m_result->setString("url"_s , in_url); |
| 7672 | return castState<UrlSet>(); |
| 7673 | } |
| 7674 | |
| 7675 | Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin) |
| 7676 | { |
| 7677 | COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set); |
| 7678 | m_result->setString("securityOrigin"_s , in_securityOrigin); |
| 7679 | return castState<SecurityOriginSet>(); |
| 7680 | } |
| 7681 | |
| 7682 | Builder<STATE | MimeTypeSet>& setMimeType(const String& in_mimeType) |
| 7683 | { |
| 7684 | COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set); |
| 7685 | m_result->setString("mimeType"_s , in_mimeType); |
| 7686 | return castState<MimeTypeSet>(); |
| 7687 | } |
| 7688 | |
| 7689 | Ref<Frame> release() |
| 7690 | { |
| 7691 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7692 | COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast); |
| 7693 | |
| 7694 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7695 | auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult)); |
| 7696 | return result; |
| 7697 | } |
| 7698 | }; |
| 7699 | |
| 7700 | /* |
| 7701 | * Synthetic constructor: |
| 7702 | * Ref<Frame> result = Frame::create() |
| 7703 | * .setId(...) |
| 7704 | * .setLoaderId(...) |
| 7705 | * .setUrl(...) |
| 7706 | * .setSecurityOrigin(...) |
| 7707 | * .setMimeType(...) |
| 7708 | * .release(); |
| 7709 | */ |
| 7710 | static Builder<NoFieldsSet> create() |
| 7711 | { |
| 7712 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7713 | } |
| 7714 | |
| 7715 | void setParentId(const String& in_opt_parentId) |
| 7716 | { |
| 7717 | JSON::ObjectBase::setString("parentId"_s , in_opt_parentId); |
| 7718 | } |
| 7719 | |
| 7720 | void setName(const String& in_opt_name) |
| 7721 | { |
| 7722 | JSON::ObjectBase::setString("name"_s , in_opt_name); |
| 7723 | } |
| 7724 | }; |
| 7725 | |
| 7726 | class FrameResource final : public JSON::ObjectBase { |
| 7727 | public: |
| 7728 | enum { |
| 7729 | NoFieldsSet = 0, |
| 7730 | UrlSet = 1 << 0, |
| 7731 | TypeSet = 1 << 1, |
| 7732 | MimeTypeSet = 1 << 2, |
| 7733 | AllFieldsSet = (UrlSet | TypeSet | MimeTypeSet) |
| 7734 | }; |
| 7735 | |
| 7736 | template<int STATE> |
| 7737 | class Builder { |
| 7738 | private: |
| 7739 | RefPtr<JSON::Object> m_result; |
| 7740 | |
| 7741 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7742 | { |
| 7743 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7744 | } |
| 7745 | |
| 7746 | Builder(Ref</*FrameResource*/JSON::Object>&& object) |
| 7747 | : m_result(WTFMove(object)) |
| 7748 | { |
| 7749 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7750 | } |
| 7751 | friend class FrameResource; |
| 7752 | public: |
| 7753 | |
| 7754 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 7755 | { |
| 7756 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 7757 | m_result->setString("url"_s , in_url); |
| 7758 | return castState<UrlSet>(); |
| 7759 | } |
| 7760 | |
| 7761 | Builder<STATE | TypeSet>& setType(Protocol::Page::ResourceType in_type) |
| 7762 | { |
| 7763 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 7764 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 7765 | return castState<TypeSet>(); |
| 7766 | } |
| 7767 | |
| 7768 | Builder<STATE | MimeTypeSet>& setMimeType(const String& in_mimeType) |
| 7769 | { |
| 7770 | COMPILE_ASSERT(!(STATE & MimeTypeSet), property_mimeType_already_set); |
| 7771 | m_result->setString("mimeType"_s , in_mimeType); |
| 7772 | return castState<MimeTypeSet>(); |
| 7773 | } |
| 7774 | |
| 7775 | Ref<FrameResource> release() |
| 7776 | { |
| 7777 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7778 | COMPILE_ASSERT(sizeof(FrameResource) == sizeof(JSON::Object), cannot_cast); |
| 7779 | |
| 7780 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7781 | auto result = WTFMove(*reinterpret_cast<Ref<FrameResource>*>(&jsonResult)); |
| 7782 | return result; |
| 7783 | } |
| 7784 | }; |
| 7785 | |
| 7786 | /* |
| 7787 | * Synthetic constructor: |
| 7788 | * Ref<FrameResource> result = FrameResource::create() |
| 7789 | * .setUrl(...) |
| 7790 | * .setType(...) |
| 7791 | * .setMimeType(...) |
| 7792 | * .release(); |
| 7793 | */ |
| 7794 | static Builder<NoFieldsSet> create() |
| 7795 | { |
| 7796 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7797 | } |
| 7798 | |
| 7799 | void setFailed(bool in_opt_failed) |
| 7800 | { |
| 7801 | JSON::ObjectBase::setBoolean("failed"_s , in_opt_failed); |
| 7802 | } |
| 7803 | |
| 7804 | void setCanceled(bool in_opt_canceled) |
| 7805 | { |
| 7806 | JSON::ObjectBase::setBoolean("canceled"_s , in_opt_canceled); |
| 7807 | } |
| 7808 | |
| 7809 | void setSourceMapURL(const String& in_opt_sourceMapURL) |
| 7810 | { |
| 7811 | JSON::ObjectBase::setString("sourceMapURL"_s , in_opt_sourceMapURL); |
| 7812 | } |
| 7813 | |
| 7814 | void setTargetId(const String& in_opt_targetId) |
| 7815 | { |
| 7816 | JSON::ObjectBase::setString("targetId"_s , in_opt_targetId); |
| 7817 | } |
| 7818 | }; |
| 7819 | |
| 7820 | /* Information about the Frame hierarchy along with their cached resources. */ |
| 7821 | class FrameResourceTree final : public JSON::ObjectBase { |
| 7822 | public: |
| 7823 | enum { |
| 7824 | NoFieldsSet = 0, |
| 7825 | FrameSet = 1 << 0, |
| 7826 | ResourcesSet = 1 << 1, |
| 7827 | AllFieldsSet = (FrameSet | ResourcesSet) |
| 7828 | }; |
| 7829 | |
| 7830 | template<int STATE> |
| 7831 | class Builder { |
| 7832 | private: |
| 7833 | RefPtr<JSON::Object> m_result; |
| 7834 | |
| 7835 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7836 | { |
| 7837 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7838 | } |
| 7839 | |
| 7840 | Builder(Ref</*FrameResourceTree*/JSON::Object>&& object) |
| 7841 | : m_result(WTFMove(object)) |
| 7842 | { |
| 7843 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7844 | } |
| 7845 | friend class FrameResourceTree; |
| 7846 | public: |
| 7847 | |
| 7848 | Builder<STATE | FrameSet>& setFrame(Ref<Protocol::Page::Frame>&& in_frame) |
| 7849 | { |
| 7850 | COMPILE_ASSERT(!(STATE & FrameSet), property_frame_already_set); |
| 7851 | m_result->setObject("frame"_s , WTFMove(in_frame)); |
| 7852 | return castState<FrameSet>(); |
| 7853 | } |
| 7854 | |
| 7855 | Builder<STATE | ResourcesSet>& setResources(Ref<JSON::ArrayOf<Protocol::Page::FrameResource>>&& in_resources) |
| 7856 | { |
| 7857 | COMPILE_ASSERT(!(STATE & ResourcesSet), property_resources_already_set); |
| 7858 | m_result->setArray("resources"_s , WTFMove(in_resources)); |
| 7859 | return castState<ResourcesSet>(); |
| 7860 | } |
| 7861 | |
| 7862 | Ref<FrameResourceTree> release() |
| 7863 | { |
| 7864 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7865 | COMPILE_ASSERT(sizeof(FrameResourceTree) == sizeof(JSON::Object), cannot_cast); |
| 7866 | |
| 7867 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7868 | auto result = WTFMove(*reinterpret_cast<Ref<FrameResourceTree>*>(&jsonResult)); |
| 7869 | return result; |
| 7870 | } |
| 7871 | }; |
| 7872 | |
| 7873 | /* |
| 7874 | * Synthetic constructor: |
| 7875 | * Ref<FrameResourceTree> result = FrameResourceTree::create() |
| 7876 | * .setFrame(...) |
| 7877 | * .setResources(...) |
| 7878 | * .release(); |
| 7879 | */ |
| 7880 | static Builder<NoFieldsSet> create() |
| 7881 | { |
| 7882 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7883 | } |
| 7884 | |
| 7885 | void setChildFrames(Ref<JSON::ArrayOf<Protocol::Page::FrameResourceTree>>&& in_opt_childFrames) |
| 7886 | { |
| 7887 | JSON::ObjectBase::setArray("childFrames"_s , WTFMove(in_opt_childFrames)); |
| 7888 | } |
| 7889 | }; |
| 7890 | |
| 7891 | /* Search result for resource. */ |
| 7892 | class SearchResult final : public JSON::ObjectBase { |
| 7893 | public: |
| 7894 | enum { |
| 7895 | NoFieldsSet = 0, |
| 7896 | UrlSet = 1 << 0, |
| 7897 | FrameIdSet = 1 << 1, |
| 7898 | MatchesCountSet = 1 << 2, |
| 7899 | AllFieldsSet = (UrlSet | FrameIdSet | MatchesCountSet) |
| 7900 | }; |
| 7901 | |
| 7902 | template<int STATE> |
| 7903 | class Builder { |
| 7904 | private: |
| 7905 | RefPtr<JSON::Object> m_result; |
| 7906 | |
| 7907 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7908 | { |
| 7909 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7910 | } |
| 7911 | |
| 7912 | Builder(Ref</*SearchResult*/JSON::Object>&& object) |
| 7913 | : m_result(WTFMove(object)) |
| 7914 | { |
| 7915 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 7916 | } |
| 7917 | friend class SearchResult; |
| 7918 | public: |
| 7919 | |
| 7920 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 7921 | { |
| 7922 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 7923 | m_result->setString("url"_s , in_url); |
| 7924 | return castState<UrlSet>(); |
| 7925 | } |
| 7926 | |
| 7927 | Builder<STATE | FrameIdSet>& setFrameId(const String& in_frameId) |
| 7928 | { |
| 7929 | COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set); |
| 7930 | m_result->setString("frameId"_s , in_frameId); |
| 7931 | return castState<FrameIdSet>(); |
| 7932 | } |
| 7933 | |
| 7934 | Builder<STATE | MatchesCountSet>& setMatchesCount(double in_matchesCount) |
| 7935 | { |
| 7936 | COMPILE_ASSERT(!(STATE & MatchesCountSet), property_matchesCount_already_set); |
| 7937 | m_result->setDouble("matchesCount"_s , in_matchesCount); |
| 7938 | return castState<MatchesCountSet>(); |
| 7939 | } |
| 7940 | |
| 7941 | Ref<SearchResult> release() |
| 7942 | { |
| 7943 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 7944 | COMPILE_ASSERT(sizeof(SearchResult) == sizeof(JSON::Object), cannot_cast); |
| 7945 | |
| 7946 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 7947 | auto result = WTFMove(*reinterpret_cast<Ref<SearchResult>*>(&jsonResult)); |
| 7948 | return result; |
| 7949 | } |
| 7950 | }; |
| 7951 | |
| 7952 | /* |
| 7953 | * Synthetic constructor: |
| 7954 | * Ref<SearchResult> result = SearchResult::create() |
| 7955 | * .setUrl(...) |
| 7956 | * .setFrameId(...) |
| 7957 | * .setMatchesCount(...) |
| 7958 | * .release(); |
| 7959 | */ |
| 7960 | static Builder<NoFieldsSet> create() |
| 7961 | { |
| 7962 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 7963 | } |
| 7964 | |
| 7965 | void setRequestId(const String& in_opt_requestId) |
| 7966 | { |
| 7967 | JSON::ObjectBase::setString("requestId"_s , in_opt_requestId); |
| 7968 | } |
| 7969 | }; |
| 7970 | |
| 7971 | /* Cookie object */ |
| 7972 | class Cookie final : public JSON::Object { |
| 7973 | public: |
| 7974 | enum { |
| 7975 | NoFieldsSet = 0, |
| 7976 | NameSet = 1 << 0, |
| 7977 | ValueSet = 1 << 1, |
| 7978 | DomainSet = 1 << 2, |
| 7979 | PathSet = 1 << 3, |
| 7980 | ExpiresSet = 1 << 4, |
| 7981 | SessionSet = 1 << 5, |
| 7982 | HttpOnlySet = 1 << 6, |
| 7983 | SecureSet = 1 << 7, |
| 7984 | SameSiteSet = 1 << 8, |
| 7985 | AllFieldsSet = (NameSet | ValueSet | DomainSet | PathSet | ExpiresSet | SessionSet | HttpOnlySet | SecureSet | SameSiteSet) |
| 7986 | }; |
| 7987 | |
| 7988 | template<int STATE> |
| 7989 | class Builder { |
| 7990 | private: |
| 7991 | RefPtr<JSON::Object> m_result; |
| 7992 | |
| 7993 | template<int STEP> Builder<STATE | STEP>& castState() |
| 7994 | { |
| 7995 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 7996 | } |
| 7997 | |
| 7998 | Builder(Ref</*Cookie*/JSON::Object>&& object) |
| 7999 | : m_result(WTFMove(object)) |
| 8000 | { |
| 8001 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8002 | } |
| 8003 | friend class Cookie; |
| 8004 | public: |
| 8005 | |
| 8006 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 8007 | { |
| 8008 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 8009 | m_result->setString("name"_s , in_name); |
| 8010 | return castState<NameSet>(); |
| 8011 | } |
| 8012 | |
| 8013 | Builder<STATE | ValueSet>& setValue(const String& in_value) |
| 8014 | { |
| 8015 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 8016 | m_result->setString("value"_s , in_value); |
| 8017 | return castState<ValueSet>(); |
| 8018 | } |
| 8019 | |
| 8020 | Builder<STATE | DomainSet>& setDomain(const String& in_domain) |
| 8021 | { |
| 8022 | COMPILE_ASSERT(!(STATE & DomainSet), property_domain_already_set); |
| 8023 | m_result->setString("domain"_s , in_domain); |
| 8024 | return castState<DomainSet>(); |
| 8025 | } |
| 8026 | |
| 8027 | Builder<STATE | PathSet>& setPath(const String& in_path) |
| 8028 | { |
| 8029 | COMPILE_ASSERT(!(STATE & PathSet), property_path_already_set); |
| 8030 | m_result->setString("path"_s , in_path); |
| 8031 | return castState<PathSet>(); |
| 8032 | } |
| 8033 | |
| 8034 | Builder<STATE | ExpiresSet>& setExpires(double in_expires) |
| 8035 | { |
| 8036 | COMPILE_ASSERT(!(STATE & ExpiresSet), property_expires_already_set); |
| 8037 | m_result->setDouble("expires"_s , in_expires); |
| 8038 | return castState<ExpiresSet>(); |
| 8039 | } |
| 8040 | |
| 8041 | Builder<STATE | SessionSet>& setSession(bool in_session) |
| 8042 | { |
| 8043 | COMPILE_ASSERT(!(STATE & SessionSet), property_session_already_set); |
| 8044 | m_result->setBoolean("session"_s , in_session); |
| 8045 | return castState<SessionSet>(); |
| 8046 | } |
| 8047 | |
| 8048 | Builder<STATE | HttpOnlySet>& setHttpOnly(bool in_httpOnly) |
| 8049 | { |
| 8050 | COMPILE_ASSERT(!(STATE & HttpOnlySet), property_httpOnly_already_set); |
| 8051 | m_result->setBoolean("httpOnly"_s , in_httpOnly); |
| 8052 | return castState<HttpOnlySet>(); |
| 8053 | } |
| 8054 | |
| 8055 | Builder<STATE | SecureSet>& setSecure(bool in_secure) |
| 8056 | { |
| 8057 | COMPILE_ASSERT(!(STATE & SecureSet), property_secure_already_set); |
| 8058 | m_result->setBoolean("secure"_s , in_secure); |
| 8059 | return castState<SecureSet>(); |
| 8060 | } |
| 8061 | |
| 8062 | Builder<STATE | SameSiteSet>& setSameSite(Protocol::Page::CookieSameSitePolicy in_sameSite) |
| 8063 | { |
| 8064 | COMPILE_ASSERT(!(STATE & SameSiteSet), property_sameSite_already_set); |
| 8065 | m_result->setString("sameSite"_s , Protocol::Helpers::getEnumConstantValue(in_sameSite)); |
| 8066 | return castState<SameSiteSet>(); |
| 8067 | } |
| 8068 | |
| 8069 | Ref<Cookie> release() |
| 8070 | { |
| 8071 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8072 | COMPILE_ASSERT(sizeof(Cookie) == sizeof(JSON::Object), cannot_cast); |
| 8073 | |
| 8074 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8075 | auto result = WTFMove(*reinterpret_cast<Ref<Cookie>*>(&jsonResult)); |
| 8076 | return result; |
| 8077 | } |
| 8078 | }; |
| 8079 | |
| 8080 | /* |
| 8081 | * Synthetic constructor: |
| 8082 | * Ref<Cookie> result = Cookie::create() |
| 8083 | * .setName(...) |
| 8084 | * .setValue(...) |
| 8085 | * .setDomain(...) |
| 8086 | * .setPath(...) |
| 8087 | * .setExpires(...) |
| 8088 | * .setSession(...) |
| 8089 | * .setHttpOnly(...) |
| 8090 | * .setSecure(...) |
| 8091 | * .setSameSite(...) |
| 8092 | * .release(); |
| 8093 | */ |
| 8094 | static Builder<NoFieldsSet> create() |
| 8095 | { |
| 8096 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8097 | } |
| 8098 | |
| 8099 | // Property names for type generated as open. |
| 8100 | JS_EXPORT_PRIVATE static const ASCIILiteral nameKey; |
| 8101 | JS_EXPORT_PRIVATE static const ASCIILiteral valueKey; |
| 8102 | JS_EXPORT_PRIVATE static const ASCIILiteral domainKey; |
| 8103 | JS_EXPORT_PRIVATE static const ASCIILiteral pathKey; |
| 8104 | JS_EXPORT_PRIVATE static const ASCIILiteral expiresKey; |
| 8105 | JS_EXPORT_PRIVATE static const ASCIILiteral sessionKey; |
| 8106 | JS_EXPORT_PRIVATE static const ASCIILiteral httpOnlyKey; |
| 8107 | JS_EXPORT_PRIVATE static const ASCIILiteral secureKey; |
| 8108 | JS_EXPORT_PRIVATE static const ASCIILiteral sameSiteKey; |
| 8109 | }; |
| 8110 | |
| 8111 | } // Page |
| 8112 | |
| 8113 | namespace Recording { |
| 8114 | |
| 8115 | /* The type of the recording. */ |
| 8116 | enum class Type { |
| 8117 | Canvas2D = 45, |
| 8118 | CanvasBitmapRenderer = 186, |
| 8119 | CanvasWebGL = 187, |
| 8120 | CanvasWebGL2 = 188, |
| 8121 | }; // enum class Type |
| 8122 | |
| 8123 | enum class Initiator { |
| 8124 | Frontend = 189, |
| 8125 | Console = 190, |
| 8126 | AutoCapture = 191, |
| 8127 | }; // enum class Initiator |
| 8128 | |
| 8129 | /* Information about the initial state of the recorded object. */ |
| 8130 | class InitialState final : public JSON::ObjectBase { |
| 8131 | public: |
| 8132 | enum { |
| 8133 | NoFieldsSet = 0, |
| 8134 | AllFieldsSet = 0 |
| 8135 | }; |
| 8136 | |
| 8137 | template<int STATE> |
| 8138 | class Builder { |
| 8139 | private: |
| 8140 | RefPtr<JSON::Object> m_result; |
| 8141 | |
| 8142 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8143 | { |
| 8144 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8145 | } |
| 8146 | |
| 8147 | Builder(Ref</*InitialState*/JSON::Object>&& object) |
| 8148 | : m_result(WTFMove(object)) |
| 8149 | { |
| 8150 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8151 | } |
| 8152 | friend class InitialState; |
| 8153 | public: |
| 8154 | |
| 8155 | Ref<InitialState> release() |
| 8156 | { |
| 8157 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8158 | COMPILE_ASSERT(sizeof(InitialState) == sizeof(JSON::Object), cannot_cast); |
| 8159 | |
| 8160 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8161 | auto result = WTFMove(*reinterpret_cast<Ref<InitialState>*>(&jsonResult)); |
| 8162 | return result; |
| 8163 | } |
| 8164 | }; |
| 8165 | |
| 8166 | /* |
| 8167 | * Synthetic constructor: |
| 8168 | * Ref<InitialState> result = InitialState::create() |
| 8169 | * .release(); |
| 8170 | */ |
| 8171 | static Builder<NoFieldsSet> create() |
| 8172 | { |
| 8173 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8174 | } |
| 8175 | |
| 8176 | void setAttributes(Ref<JSON::Object>&& in_opt_attributes) |
| 8177 | { |
| 8178 | JSON::ObjectBase::setObject("attributes"_s , WTFMove(in_opt_attributes)); |
| 8179 | } |
| 8180 | |
| 8181 | void setStates(Ref<JSON::ArrayOf<JSON::Object>>&& in_opt_states) |
| 8182 | { |
| 8183 | JSON::ObjectBase::setArray("states"_s , WTFMove(in_opt_states)); |
| 8184 | } |
| 8185 | |
| 8186 | void setParameters(Ref<JSON::ArrayOf<JSON::Value>>&& in_opt_parameters) |
| 8187 | { |
| 8188 | JSON::ObjectBase::setArray("parameters"_s , WTFMove(in_opt_parameters)); |
| 8189 | } |
| 8190 | |
| 8191 | void setContent(const String& in_opt_content) |
| 8192 | { |
| 8193 | JSON::ObjectBase::setString("content"_s , in_opt_content); |
| 8194 | } |
| 8195 | }; |
| 8196 | |
| 8197 | /* Container object for a single frame of the recording. */ |
| 8198 | class Frame final : public JSON::ObjectBase { |
| 8199 | public: |
| 8200 | enum { |
| 8201 | NoFieldsSet = 0, |
| 8202 | ActionsSet = 1 << 0, |
| 8203 | AllFieldsSet = (ActionsSet) |
| 8204 | }; |
| 8205 | |
| 8206 | template<int STATE> |
| 8207 | class Builder { |
| 8208 | private: |
| 8209 | RefPtr<JSON::Object> m_result; |
| 8210 | |
| 8211 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8212 | { |
| 8213 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8214 | } |
| 8215 | |
| 8216 | Builder(Ref</*Frame*/JSON::Object>&& object) |
| 8217 | : m_result(WTFMove(object)) |
| 8218 | { |
| 8219 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8220 | } |
| 8221 | friend class Frame; |
| 8222 | public: |
| 8223 | |
| 8224 | Builder<STATE | ActionsSet>& setActions(Ref<JSON::ArrayOf<JSON::Value>>&& in_actions) |
| 8225 | { |
| 8226 | COMPILE_ASSERT(!(STATE & ActionsSet), property_actions_already_set); |
| 8227 | m_result->setArray("actions"_s , WTFMove(in_actions)); |
| 8228 | return castState<ActionsSet>(); |
| 8229 | } |
| 8230 | |
| 8231 | Ref<Frame> release() |
| 8232 | { |
| 8233 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8234 | COMPILE_ASSERT(sizeof(Frame) == sizeof(JSON::Object), cannot_cast); |
| 8235 | |
| 8236 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8237 | auto result = WTFMove(*reinterpret_cast<Ref<Frame>*>(&jsonResult)); |
| 8238 | return result; |
| 8239 | } |
| 8240 | }; |
| 8241 | |
| 8242 | /* |
| 8243 | * Synthetic constructor: |
| 8244 | * Ref<Frame> result = Frame::create() |
| 8245 | * .setActions(...) |
| 8246 | * .release(); |
| 8247 | */ |
| 8248 | static Builder<NoFieldsSet> create() |
| 8249 | { |
| 8250 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8251 | } |
| 8252 | |
| 8253 | void setDuration(double in_opt_duration) |
| 8254 | { |
| 8255 | JSON::ObjectBase::setDouble("duration"_s , in_opt_duration); |
| 8256 | } |
| 8257 | |
| 8258 | void setIncomplete(bool in_opt_incomplete) |
| 8259 | { |
| 8260 | JSON::ObjectBase::setBoolean("incomplete"_s , in_opt_incomplete); |
| 8261 | } |
| 8262 | }; |
| 8263 | |
| 8264 | class Recording final : public JSON::ObjectBase { |
| 8265 | public: |
| 8266 | enum { |
| 8267 | NoFieldsSet = 0, |
| 8268 | VersionSet = 1 << 0, |
| 8269 | TypeSet = 1 << 1, |
| 8270 | InitialStateSet = 1 << 2, |
| 8271 | DataSet = 1 << 3, |
| 8272 | AllFieldsSet = (VersionSet | TypeSet | InitialStateSet | DataSet) |
| 8273 | }; |
| 8274 | |
| 8275 | template<int STATE> |
| 8276 | class Builder { |
| 8277 | private: |
| 8278 | RefPtr<JSON::Object> m_result; |
| 8279 | |
| 8280 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8281 | { |
| 8282 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8283 | } |
| 8284 | |
| 8285 | Builder(Ref</*Recording*/JSON::Object>&& object) |
| 8286 | : m_result(WTFMove(object)) |
| 8287 | { |
| 8288 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8289 | } |
| 8290 | friend class Recording; |
| 8291 | public: |
| 8292 | |
| 8293 | Builder<STATE | VersionSet>& setVersion(int in_version) |
| 8294 | { |
| 8295 | COMPILE_ASSERT(!(STATE & VersionSet), property_version_already_set); |
| 8296 | m_result->setInteger("version"_s , in_version); |
| 8297 | return castState<VersionSet>(); |
| 8298 | } |
| 8299 | |
| 8300 | Builder<STATE | TypeSet>& setType(Protocol::Recording::Type in_type) |
| 8301 | { |
| 8302 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 8303 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 8304 | return castState<TypeSet>(); |
| 8305 | } |
| 8306 | |
| 8307 | Builder<STATE | InitialStateSet>& setInitialState(Ref<Protocol::Recording::InitialState>&& in_initialState) |
| 8308 | { |
| 8309 | COMPILE_ASSERT(!(STATE & InitialStateSet), property_initialState_already_set); |
| 8310 | m_result->setObject("initialState"_s , WTFMove(in_initialState)); |
| 8311 | return castState<InitialStateSet>(); |
| 8312 | } |
| 8313 | |
| 8314 | Builder<STATE | DataSet>& setData(Ref<JSON::ArrayOf<JSON::Value>>&& in_data) |
| 8315 | { |
| 8316 | COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set); |
| 8317 | m_result->setArray("data"_s , WTFMove(in_data)); |
| 8318 | return castState<DataSet>(); |
| 8319 | } |
| 8320 | |
| 8321 | Ref<Recording> release() |
| 8322 | { |
| 8323 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8324 | COMPILE_ASSERT(sizeof(Recording) == sizeof(JSON::Object), cannot_cast); |
| 8325 | |
| 8326 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8327 | auto result = WTFMove(*reinterpret_cast<Ref<Recording>*>(&jsonResult)); |
| 8328 | return result; |
| 8329 | } |
| 8330 | }; |
| 8331 | |
| 8332 | /* |
| 8333 | * Synthetic constructor: |
| 8334 | * Ref<Recording> result = Recording::create() |
| 8335 | * .setVersion(...) |
| 8336 | * .setType(...) |
| 8337 | * .setInitialState(...) |
| 8338 | * .setData(...) |
| 8339 | * .release(); |
| 8340 | */ |
| 8341 | static Builder<NoFieldsSet> create() |
| 8342 | { |
| 8343 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8344 | } |
| 8345 | |
| 8346 | void setName(const String& in_opt_name) |
| 8347 | { |
| 8348 | JSON::ObjectBase::setString("name"_s , in_opt_name); |
| 8349 | } |
| 8350 | }; |
| 8351 | |
| 8352 | } // Recording |
| 8353 | |
| 8354 | namespace Runtime { |
| 8355 | |
| 8356 | /* Mirror object referencing original JavaScript object. */ |
| 8357 | class RemoteObject final : public JSON::ObjectBase { |
| 8358 | public: |
| 8359 | // Named after property name 'type' while generating RemoteObject. |
| 8360 | enum class Type { |
| 8361 | Object = 192, |
| 8362 | Function = 193, |
| 8363 | Undefined = 194, |
| 8364 | String = 133, |
| 8365 | Number = 132, |
| 8366 | Boolean = 195, |
| 8367 | Symbol = 196, |
| 8368 | Bigint = 197, |
| 8369 | }; // enum class Type |
| 8370 | |
| 8371 | // Named after property name 'subtype' while generating RemoteObject. |
| 8372 | enum class Subtype { |
| 8373 | Array = 134, |
| 8374 | Null = 135, |
| 8375 | Node = 198, |
| 8376 | Regexp = 199, |
| 8377 | Date = 107, |
| 8378 | Error = 77, |
| 8379 | Map = 200, |
| 8380 | Set = 201, |
| 8381 | Weakmap = 202, |
| 8382 | Weakset = 203, |
| 8383 | Iterator = 204, |
| 8384 | Class = 205, |
| 8385 | Proxy = 206, |
| 8386 | }; // enum class Subtype |
| 8387 | |
| 8388 | enum { |
| 8389 | NoFieldsSet = 0, |
| 8390 | TypeSet = 1 << 0, |
| 8391 | AllFieldsSet = (TypeSet) |
| 8392 | }; |
| 8393 | |
| 8394 | template<int STATE> |
| 8395 | class Builder { |
| 8396 | private: |
| 8397 | RefPtr<JSON::Object> m_result; |
| 8398 | |
| 8399 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8400 | { |
| 8401 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8402 | } |
| 8403 | |
| 8404 | Builder(Ref</*RemoteObject*/JSON::Object>&& object) |
| 8405 | : m_result(WTFMove(object)) |
| 8406 | { |
| 8407 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8408 | } |
| 8409 | friend class RemoteObject; |
| 8410 | public: |
| 8411 | |
| 8412 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 8413 | { |
| 8414 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 8415 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 8416 | return castState<TypeSet>(); |
| 8417 | } |
| 8418 | |
| 8419 | Ref<RemoteObject> release() |
| 8420 | { |
| 8421 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8422 | COMPILE_ASSERT(sizeof(RemoteObject) == sizeof(JSON::Object), cannot_cast); |
| 8423 | |
| 8424 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8425 | auto result = WTFMove(*reinterpret_cast<Ref<RemoteObject>*>(&jsonResult)); |
| 8426 | return result; |
| 8427 | } |
| 8428 | }; |
| 8429 | |
| 8430 | /* |
| 8431 | * Synthetic constructor: |
| 8432 | * Ref<RemoteObject> result = RemoteObject::create() |
| 8433 | * .setType(...) |
| 8434 | * .release(); |
| 8435 | */ |
| 8436 | static Builder<NoFieldsSet> create() |
| 8437 | { |
| 8438 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8439 | } |
| 8440 | |
| 8441 | void setSubtype(Subtype in_opt_subtype) |
| 8442 | { |
| 8443 | JSON::ObjectBase::setString("subtype"_s , Protocol::Helpers::getEnumConstantValue(in_opt_subtype)); |
| 8444 | } |
| 8445 | |
| 8446 | void setClassName(const String& in_opt_className) |
| 8447 | { |
| 8448 | JSON::ObjectBase::setString("className"_s , in_opt_className); |
| 8449 | } |
| 8450 | |
| 8451 | void setValue(Ref<JSON::Value>&& in_opt_value) |
| 8452 | { |
| 8453 | JSON::ObjectBase::setValue("value"_s , WTFMove(in_opt_value)); |
| 8454 | } |
| 8455 | |
| 8456 | void setDescription(const String& in_opt_description) |
| 8457 | { |
| 8458 | JSON::ObjectBase::setString("description"_s , in_opt_description); |
| 8459 | } |
| 8460 | |
| 8461 | void setObjectId(const String& in_opt_objectId) |
| 8462 | { |
| 8463 | JSON::ObjectBase::setString("objectId"_s , in_opt_objectId); |
| 8464 | } |
| 8465 | |
| 8466 | void setSize(int in_opt_size) |
| 8467 | { |
| 8468 | JSON::ObjectBase::setInteger("size"_s , in_opt_size); |
| 8469 | } |
| 8470 | |
| 8471 | void setClassPrototype(Ref<Protocol::Runtime::RemoteObject>&& in_opt_classPrototype) |
| 8472 | { |
| 8473 | JSON::ObjectBase::setObject("classPrototype"_s , WTFMove(in_opt_classPrototype)); |
| 8474 | } |
| 8475 | |
| 8476 | void setPreview(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_preview) |
| 8477 | { |
| 8478 | JSON::ObjectBase::setObject("preview"_s , WTFMove(in_opt_preview)); |
| 8479 | } |
| 8480 | }; |
| 8481 | |
| 8482 | /* Object containing abbreviated remote object value. */ |
| 8483 | class ObjectPreview final : public JSON::ObjectBase { |
| 8484 | public: |
| 8485 | // Named after property name 'type' while generating ObjectPreview. |
| 8486 | enum class Type { |
| 8487 | Object = 192, |
| 8488 | Function = 193, |
| 8489 | Undefined = 194, |
| 8490 | String = 133, |
| 8491 | Number = 132, |
| 8492 | Boolean = 195, |
| 8493 | Symbol = 196, |
| 8494 | Bigint = 197, |
| 8495 | }; // enum class Type |
| 8496 | |
| 8497 | // Named after property name 'subtype' while generating ObjectPreview. |
| 8498 | enum class Subtype { |
| 8499 | Array = 134, |
| 8500 | Null = 135, |
| 8501 | Node = 198, |
| 8502 | Regexp = 199, |
| 8503 | Date = 107, |
| 8504 | Error = 77, |
| 8505 | Map = 200, |
| 8506 | Set = 201, |
| 8507 | Weakmap = 202, |
| 8508 | Weakset = 203, |
| 8509 | Iterator = 204, |
| 8510 | Class = 205, |
| 8511 | Proxy = 206, |
| 8512 | }; // enum class Subtype |
| 8513 | |
| 8514 | enum { |
| 8515 | NoFieldsSet = 0, |
| 8516 | TypeSet = 1 << 0, |
| 8517 | LosslessSet = 1 << 1, |
| 8518 | AllFieldsSet = (TypeSet | LosslessSet) |
| 8519 | }; |
| 8520 | |
| 8521 | template<int STATE> |
| 8522 | class Builder { |
| 8523 | private: |
| 8524 | RefPtr<JSON::Object> m_result; |
| 8525 | |
| 8526 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8527 | { |
| 8528 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8529 | } |
| 8530 | |
| 8531 | Builder(Ref</*ObjectPreview*/JSON::Object>&& object) |
| 8532 | : m_result(WTFMove(object)) |
| 8533 | { |
| 8534 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8535 | } |
| 8536 | friend class ObjectPreview; |
| 8537 | public: |
| 8538 | |
| 8539 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 8540 | { |
| 8541 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 8542 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 8543 | return castState<TypeSet>(); |
| 8544 | } |
| 8545 | |
| 8546 | Builder<STATE | LosslessSet>& setLossless(bool in_lossless) |
| 8547 | { |
| 8548 | COMPILE_ASSERT(!(STATE & LosslessSet), property_lossless_already_set); |
| 8549 | m_result->setBoolean("lossless"_s , in_lossless); |
| 8550 | return castState<LosslessSet>(); |
| 8551 | } |
| 8552 | |
| 8553 | Ref<ObjectPreview> release() |
| 8554 | { |
| 8555 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8556 | COMPILE_ASSERT(sizeof(ObjectPreview) == sizeof(JSON::Object), cannot_cast); |
| 8557 | |
| 8558 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8559 | auto result = WTFMove(*reinterpret_cast<Ref<ObjectPreview>*>(&jsonResult)); |
| 8560 | return result; |
| 8561 | } |
| 8562 | }; |
| 8563 | |
| 8564 | /* |
| 8565 | * Synthetic constructor: |
| 8566 | * Ref<ObjectPreview> result = ObjectPreview::create() |
| 8567 | * .setType(...) |
| 8568 | * .setLossless(...) |
| 8569 | * .release(); |
| 8570 | */ |
| 8571 | static Builder<NoFieldsSet> create() |
| 8572 | { |
| 8573 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8574 | } |
| 8575 | |
| 8576 | void setSubtype(Subtype in_opt_subtype) |
| 8577 | { |
| 8578 | JSON::ObjectBase::setString("subtype"_s , Protocol::Helpers::getEnumConstantValue(in_opt_subtype)); |
| 8579 | } |
| 8580 | |
| 8581 | void setDescription(const String& in_opt_description) |
| 8582 | { |
| 8583 | JSON::ObjectBase::setString("description"_s , in_opt_description); |
| 8584 | } |
| 8585 | |
| 8586 | void setOverflow(bool in_opt_overflow) |
| 8587 | { |
| 8588 | JSON::ObjectBase::setBoolean("overflow"_s , in_opt_overflow); |
| 8589 | } |
| 8590 | |
| 8591 | void setProperties(Ref<JSON::ArrayOf<Protocol::Runtime::PropertyPreview>>&& in_opt_properties) |
| 8592 | { |
| 8593 | JSON::ObjectBase::setArray("properties"_s , WTFMove(in_opt_properties)); |
| 8594 | } |
| 8595 | |
| 8596 | void setEntries(Ref<JSON::ArrayOf<Protocol::Runtime::EntryPreview>>&& in_opt_entries) |
| 8597 | { |
| 8598 | JSON::ObjectBase::setArray("entries"_s , WTFMove(in_opt_entries)); |
| 8599 | } |
| 8600 | |
| 8601 | void setSize(int in_opt_size) |
| 8602 | { |
| 8603 | JSON::ObjectBase::setInteger("size"_s , in_opt_size); |
| 8604 | } |
| 8605 | }; |
| 8606 | |
| 8607 | class PropertyPreview final : public JSON::ObjectBase { |
| 8608 | public: |
| 8609 | // Named after property name 'type' while generating PropertyPreview. |
| 8610 | enum class Type { |
| 8611 | Object = 192, |
| 8612 | Function = 193, |
| 8613 | Undefined = 194, |
| 8614 | String = 133, |
| 8615 | Number = 132, |
| 8616 | Boolean = 195, |
| 8617 | Symbol = 196, |
| 8618 | Bigint = 197, |
| 8619 | Accessor = 207, |
| 8620 | }; // enum class Type |
| 8621 | |
| 8622 | // Named after property name 'subtype' while generating PropertyPreview. |
| 8623 | enum class Subtype { |
| 8624 | Array = 134, |
| 8625 | Null = 135, |
| 8626 | Node = 198, |
| 8627 | Regexp = 199, |
| 8628 | Date = 107, |
| 8629 | Error = 77, |
| 8630 | Map = 200, |
| 8631 | Set = 201, |
| 8632 | Weakmap = 202, |
| 8633 | Weakset = 203, |
| 8634 | Iterator = 204, |
| 8635 | Class = 205, |
| 8636 | Proxy = 206, |
| 8637 | }; // enum class Subtype |
| 8638 | |
| 8639 | enum { |
| 8640 | NoFieldsSet = 0, |
| 8641 | NameSet = 1 << 0, |
| 8642 | TypeSet = 1 << 1, |
| 8643 | AllFieldsSet = (NameSet | TypeSet) |
| 8644 | }; |
| 8645 | |
| 8646 | template<int STATE> |
| 8647 | class Builder { |
| 8648 | private: |
| 8649 | RefPtr<JSON::Object> m_result; |
| 8650 | |
| 8651 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8652 | { |
| 8653 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8654 | } |
| 8655 | |
| 8656 | Builder(Ref</*PropertyPreview*/JSON::Object>&& object) |
| 8657 | : m_result(WTFMove(object)) |
| 8658 | { |
| 8659 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8660 | } |
| 8661 | friend class PropertyPreview; |
| 8662 | public: |
| 8663 | |
| 8664 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 8665 | { |
| 8666 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 8667 | m_result->setString("name"_s , in_name); |
| 8668 | return castState<NameSet>(); |
| 8669 | } |
| 8670 | |
| 8671 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 8672 | { |
| 8673 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 8674 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 8675 | return castState<TypeSet>(); |
| 8676 | } |
| 8677 | |
| 8678 | Ref<PropertyPreview> release() |
| 8679 | { |
| 8680 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8681 | COMPILE_ASSERT(sizeof(PropertyPreview) == sizeof(JSON::Object), cannot_cast); |
| 8682 | |
| 8683 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8684 | auto result = WTFMove(*reinterpret_cast<Ref<PropertyPreview>*>(&jsonResult)); |
| 8685 | return result; |
| 8686 | } |
| 8687 | }; |
| 8688 | |
| 8689 | /* |
| 8690 | * Synthetic constructor: |
| 8691 | * Ref<PropertyPreview> result = PropertyPreview::create() |
| 8692 | * .setName(...) |
| 8693 | * .setType(...) |
| 8694 | * .release(); |
| 8695 | */ |
| 8696 | static Builder<NoFieldsSet> create() |
| 8697 | { |
| 8698 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8699 | } |
| 8700 | |
| 8701 | void setSubtype(Subtype in_opt_subtype) |
| 8702 | { |
| 8703 | JSON::ObjectBase::setString("subtype"_s , Protocol::Helpers::getEnumConstantValue(in_opt_subtype)); |
| 8704 | } |
| 8705 | |
| 8706 | void setValue(const String& in_opt_value) |
| 8707 | { |
| 8708 | JSON::ObjectBase::setString("value"_s , in_opt_value); |
| 8709 | } |
| 8710 | |
| 8711 | void setValuePreview(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_valuePreview) |
| 8712 | { |
| 8713 | JSON::ObjectBase::setObject("valuePreview"_s , WTFMove(in_opt_valuePreview)); |
| 8714 | } |
| 8715 | |
| 8716 | void setInternal(bool in_opt_internal) |
| 8717 | { |
| 8718 | JSON::ObjectBase::setBoolean("internal"_s , in_opt_internal); |
| 8719 | } |
| 8720 | }; |
| 8721 | |
| 8722 | class EntryPreview final : public JSON::ObjectBase { |
| 8723 | public: |
| 8724 | enum { |
| 8725 | NoFieldsSet = 0, |
| 8726 | ValueSet = 1 << 0, |
| 8727 | AllFieldsSet = (ValueSet) |
| 8728 | }; |
| 8729 | |
| 8730 | template<int STATE> |
| 8731 | class Builder { |
| 8732 | private: |
| 8733 | RefPtr<JSON::Object> m_result; |
| 8734 | |
| 8735 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8736 | { |
| 8737 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8738 | } |
| 8739 | |
| 8740 | Builder(Ref</*EntryPreview*/JSON::Object>&& object) |
| 8741 | : m_result(WTFMove(object)) |
| 8742 | { |
| 8743 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8744 | } |
| 8745 | friend class EntryPreview; |
| 8746 | public: |
| 8747 | |
| 8748 | Builder<STATE | ValueSet>& setValue(Ref<Protocol::Runtime::ObjectPreview>&& in_value) |
| 8749 | { |
| 8750 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 8751 | m_result->setObject("value"_s , WTFMove(in_value)); |
| 8752 | return castState<ValueSet>(); |
| 8753 | } |
| 8754 | |
| 8755 | Ref<EntryPreview> release() |
| 8756 | { |
| 8757 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8758 | COMPILE_ASSERT(sizeof(EntryPreview) == sizeof(JSON::Object), cannot_cast); |
| 8759 | |
| 8760 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8761 | auto result = WTFMove(*reinterpret_cast<Ref<EntryPreview>*>(&jsonResult)); |
| 8762 | return result; |
| 8763 | } |
| 8764 | }; |
| 8765 | |
| 8766 | /* |
| 8767 | * Synthetic constructor: |
| 8768 | * Ref<EntryPreview> result = EntryPreview::create() |
| 8769 | * .setValue(...) |
| 8770 | * .release(); |
| 8771 | */ |
| 8772 | static Builder<NoFieldsSet> create() |
| 8773 | { |
| 8774 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8775 | } |
| 8776 | |
| 8777 | void setKey(Ref<Protocol::Runtime::ObjectPreview>&& in_opt_key) |
| 8778 | { |
| 8779 | JSON::ObjectBase::setObject("key"_s , WTFMove(in_opt_key)); |
| 8780 | } |
| 8781 | }; |
| 8782 | |
| 8783 | class CollectionEntry final : public JSON::ObjectBase { |
| 8784 | public: |
| 8785 | enum { |
| 8786 | NoFieldsSet = 0, |
| 8787 | ValueSet = 1 << 0, |
| 8788 | AllFieldsSet = (ValueSet) |
| 8789 | }; |
| 8790 | |
| 8791 | template<int STATE> |
| 8792 | class Builder { |
| 8793 | private: |
| 8794 | RefPtr<JSON::Object> m_result; |
| 8795 | |
| 8796 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8797 | { |
| 8798 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8799 | } |
| 8800 | |
| 8801 | Builder(Ref</*CollectionEntry*/JSON::Object>&& object) |
| 8802 | : m_result(WTFMove(object)) |
| 8803 | { |
| 8804 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8805 | } |
| 8806 | friend class CollectionEntry; |
| 8807 | public: |
| 8808 | |
| 8809 | Builder<STATE | ValueSet>& setValue(Ref<Protocol::Runtime::RemoteObject>&& in_value) |
| 8810 | { |
| 8811 | COMPILE_ASSERT(!(STATE & ValueSet), property_value_already_set); |
| 8812 | m_result->setObject("value"_s , WTFMove(in_value)); |
| 8813 | return castState<ValueSet>(); |
| 8814 | } |
| 8815 | |
| 8816 | Ref<CollectionEntry> release() |
| 8817 | { |
| 8818 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8819 | COMPILE_ASSERT(sizeof(CollectionEntry) == sizeof(JSON::Object), cannot_cast); |
| 8820 | |
| 8821 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8822 | auto result = WTFMove(*reinterpret_cast<Ref<CollectionEntry>*>(&jsonResult)); |
| 8823 | return result; |
| 8824 | } |
| 8825 | }; |
| 8826 | |
| 8827 | /* |
| 8828 | * Synthetic constructor: |
| 8829 | * Ref<CollectionEntry> result = CollectionEntry::create() |
| 8830 | * .setValue(...) |
| 8831 | * .release(); |
| 8832 | */ |
| 8833 | static Builder<NoFieldsSet> create() |
| 8834 | { |
| 8835 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8836 | } |
| 8837 | |
| 8838 | void setKey(Ref<Protocol::Runtime::RemoteObject>&& in_opt_key) |
| 8839 | { |
| 8840 | JSON::ObjectBase::setObject("key"_s , WTFMove(in_opt_key)); |
| 8841 | } |
| 8842 | }; |
| 8843 | |
| 8844 | /* Object property descriptor. */ |
| 8845 | class PropertyDescriptor final : public JSON::ObjectBase { |
| 8846 | public: |
| 8847 | enum { |
| 8848 | NoFieldsSet = 0, |
| 8849 | NameSet = 1 << 0, |
| 8850 | AllFieldsSet = (NameSet) |
| 8851 | }; |
| 8852 | |
| 8853 | template<int STATE> |
| 8854 | class Builder { |
| 8855 | private: |
| 8856 | RefPtr<JSON::Object> m_result; |
| 8857 | |
| 8858 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8859 | { |
| 8860 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8861 | } |
| 8862 | |
| 8863 | Builder(Ref</*PropertyDescriptor*/JSON::Object>&& object) |
| 8864 | : m_result(WTFMove(object)) |
| 8865 | { |
| 8866 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8867 | } |
| 8868 | friend class PropertyDescriptor; |
| 8869 | public: |
| 8870 | |
| 8871 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 8872 | { |
| 8873 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 8874 | m_result->setString("name"_s , in_name); |
| 8875 | return castState<NameSet>(); |
| 8876 | } |
| 8877 | |
| 8878 | Ref<PropertyDescriptor> release() |
| 8879 | { |
| 8880 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8881 | COMPILE_ASSERT(sizeof(PropertyDescriptor) == sizeof(JSON::Object), cannot_cast); |
| 8882 | |
| 8883 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8884 | auto result = WTFMove(*reinterpret_cast<Ref<PropertyDescriptor>*>(&jsonResult)); |
| 8885 | return result; |
| 8886 | } |
| 8887 | }; |
| 8888 | |
| 8889 | /* |
| 8890 | * Synthetic constructor: |
| 8891 | * Ref<PropertyDescriptor> result = PropertyDescriptor::create() |
| 8892 | * .setName(...) |
| 8893 | * .release(); |
| 8894 | */ |
| 8895 | static Builder<NoFieldsSet> create() |
| 8896 | { |
| 8897 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 8898 | } |
| 8899 | |
| 8900 | void setValue(Ref<Protocol::Runtime::RemoteObject>&& in_opt_value) |
| 8901 | { |
| 8902 | JSON::ObjectBase::setObject("value"_s , WTFMove(in_opt_value)); |
| 8903 | } |
| 8904 | |
| 8905 | void setWritable(bool in_opt_writable) |
| 8906 | { |
| 8907 | JSON::ObjectBase::setBoolean("writable"_s , in_opt_writable); |
| 8908 | } |
| 8909 | |
| 8910 | void setGet(Ref<Protocol::Runtime::RemoteObject>&& in_opt_get) |
| 8911 | { |
| 8912 | JSON::ObjectBase::setObject("get"_s , WTFMove(in_opt_get)); |
| 8913 | } |
| 8914 | |
| 8915 | void setSet(Ref<Protocol::Runtime::RemoteObject>&& in_opt_set) |
| 8916 | { |
| 8917 | JSON::ObjectBase::setObject("set"_s , WTFMove(in_opt_set)); |
| 8918 | } |
| 8919 | |
| 8920 | void setWasThrown(bool in_opt_wasThrown) |
| 8921 | { |
| 8922 | JSON::ObjectBase::setBoolean("wasThrown"_s , in_opt_wasThrown); |
| 8923 | } |
| 8924 | |
| 8925 | void setConfigurable(bool in_opt_configurable) |
| 8926 | { |
| 8927 | JSON::ObjectBase::setBoolean("configurable"_s , in_opt_configurable); |
| 8928 | } |
| 8929 | |
| 8930 | void setEnumerable(bool in_opt_enumerable) |
| 8931 | { |
| 8932 | JSON::ObjectBase::setBoolean("enumerable"_s , in_opt_enumerable); |
| 8933 | } |
| 8934 | |
| 8935 | void setIsOwn(bool in_opt_isOwn) |
| 8936 | { |
| 8937 | JSON::ObjectBase::setBoolean("isOwn"_s , in_opt_isOwn); |
| 8938 | } |
| 8939 | |
| 8940 | void setSymbol(Ref<Protocol::Runtime::RemoteObject>&& in_opt_symbol) |
| 8941 | { |
| 8942 | JSON::ObjectBase::setObject("symbol"_s , WTFMove(in_opt_symbol)); |
| 8943 | } |
| 8944 | |
| 8945 | void setNativeGetter(bool in_opt_nativeGetter) |
| 8946 | { |
| 8947 | JSON::ObjectBase::setBoolean("nativeGetter"_s , in_opt_nativeGetter); |
| 8948 | } |
| 8949 | }; |
| 8950 | |
| 8951 | /* Object internal property descriptor. This property isn't normally visible in JavaScript code. */ |
| 8952 | class InternalPropertyDescriptor final : public JSON::ObjectBase { |
| 8953 | public: |
| 8954 | enum { |
| 8955 | NoFieldsSet = 0, |
| 8956 | NameSet = 1 << 0, |
| 8957 | AllFieldsSet = (NameSet) |
| 8958 | }; |
| 8959 | |
| 8960 | template<int STATE> |
| 8961 | class Builder { |
| 8962 | private: |
| 8963 | RefPtr<JSON::Object> m_result; |
| 8964 | |
| 8965 | template<int STEP> Builder<STATE | STEP>& castState() |
| 8966 | { |
| 8967 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 8968 | } |
| 8969 | |
| 8970 | Builder(Ref</*InternalPropertyDescriptor*/JSON::Object>&& object) |
| 8971 | : m_result(WTFMove(object)) |
| 8972 | { |
| 8973 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 8974 | } |
| 8975 | friend class InternalPropertyDescriptor; |
| 8976 | public: |
| 8977 | |
| 8978 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 8979 | { |
| 8980 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 8981 | m_result->setString("name"_s , in_name); |
| 8982 | return castState<NameSet>(); |
| 8983 | } |
| 8984 | |
| 8985 | Ref<InternalPropertyDescriptor> release() |
| 8986 | { |
| 8987 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 8988 | COMPILE_ASSERT(sizeof(InternalPropertyDescriptor) == sizeof(JSON::Object), cannot_cast); |
| 8989 | |
| 8990 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 8991 | auto result = WTFMove(*reinterpret_cast<Ref<InternalPropertyDescriptor>*>(&jsonResult)); |
| 8992 | return result; |
| 8993 | } |
| 8994 | }; |
| 8995 | |
| 8996 | /* |
| 8997 | * Synthetic constructor: |
| 8998 | * Ref<InternalPropertyDescriptor> result = InternalPropertyDescriptor::create() |
| 8999 | * .setName(...) |
| 9000 | * .release(); |
| 9001 | */ |
| 9002 | static Builder<NoFieldsSet> create() |
| 9003 | { |
| 9004 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9005 | } |
| 9006 | |
| 9007 | void setValue(Ref<Protocol::Runtime::RemoteObject>&& in_opt_value) |
| 9008 | { |
| 9009 | JSON::ObjectBase::setObject("value"_s , WTFMove(in_opt_value)); |
| 9010 | } |
| 9011 | }; |
| 9012 | |
| 9013 | /* Represents function call argument. Either remote object id <code>objectId</code> or primitive <code>value</code> or neither of (for undefined) them should be specified. */ |
| 9014 | class CallArgument final : public JSON::Object { |
| 9015 | public: |
| 9016 | enum { |
| 9017 | NoFieldsSet = 0, |
| 9018 | AllFieldsSet = 0 |
| 9019 | }; |
| 9020 | |
| 9021 | template<int STATE> |
| 9022 | class Builder { |
| 9023 | private: |
| 9024 | RefPtr<JSON::Object> m_result; |
| 9025 | |
| 9026 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9027 | { |
| 9028 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9029 | } |
| 9030 | |
| 9031 | Builder(Ref</*CallArgument*/JSON::Object>&& object) |
| 9032 | : m_result(WTFMove(object)) |
| 9033 | { |
| 9034 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9035 | } |
| 9036 | friend class CallArgument; |
| 9037 | public: |
| 9038 | |
| 9039 | Ref<CallArgument> release() |
| 9040 | { |
| 9041 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9042 | COMPILE_ASSERT(sizeof(CallArgument) == sizeof(JSON::Object), cannot_cast); |
| 9043 | |
| 9044 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9045 | auto result = WTFMove(*reinterpret_cast<Ref<CallArgument>*>(&jsonResult)); |
| 9046 | return result; |
| 9047 | } |
| 9048 | }; |
| 9049 | |
| 9050 | /* |
| 9051 | * Synthetic constructor: |
| 9052 | * Ref<CallArgument> result = CallArgument::create() |
| 9053 | * .release(); |
| 9054 | */ |
| 9055 | static Builder<NoFieldsSet> create() |
| 9056 | { |
| 9057 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9058 | } |
| 9059 | |
| 9060 | void setValue(Ref<JSON::Value>&& in_opt_value) |
| 9061 | { |
| 9062 | JSON::ObjectBase::setValue("value"_s , WTFMove(in_opt_value)); |
| 9063 | } |
| 9064 | |
| 9065 | void setObjectId(const String& in_opt_objectId) |
| 9066 | { |
| 9067 | JSON::ObjectBase::setString("objectId"_s , in_opt_objectId); |
| 9068 | } |
| 9069 | |
| 9070 | // Property names for type generated as open. |
| 9071 | JS_EXPORT_PRIVATE static const ASCIILiteral objectIdKey; |
| 9072 | }; |
| 9073 | |
| 9074 | /* Type of the execution context. */ |
| 9075 | enum class ExecutionContextType { |
| 9076 | Normal = 5, |
| 9077 | User = 16, |
| 9078 | Internal = 208, |
| 9079 | }; // enum class ExecutionContextType |
| 9080 | |
| 9081 | /* Description of an isolated world. */ |
| 9082 | class ExecutionContextDescription final : public JSON::ObjectBase { |
| 9083 | public: |
| 9084 | enum { |
| 9085 | NoFieldsSet = 0, |
| 9086 | IdSet = 1 << 0, |
| 9087 | TypeSet = 1 << 1, |
| 9088 | NameSet = 1 << 2, |
| 9089 | FrameIdSet = 1 << 3, |
| 9090 | AllFieldsSet = (IdSet | TypeSet | NameSet | FrameIdSet) |
| 9091 | }; |
| 9092 | |
| 9093 | template<int STATE> |
| 9094 | class Builder { |
| 9095 | private: |
| 9096 | RefPtr<JSON::Object> m_result; |
| 9097 | |
| 9098 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9099 | { |
| 9100 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9101 | } |
| 9102 | |
| 9103 | Builder(Ref</*ExecutionContextDescription*/JSON::Object>&& object) |
| 9104 | : m_result(WTFMove(object)) |
| 9105 | { |
| 9106 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9107 | } |
| 9108 | friend class ExecutionContextDescription; |
| 9109 | public: |
| 9110 | |
| 9111 | Builder<STATE | IdSet>& setId(int in_id) |
| 9112 | { |
| 9113 | COMPILE_ASSERT(!(STATE & IdSet), property_id_already_set); |
| 9114 | m_result->setInteger("id"_s , in_id); |
| 9115 | return castState<IdSet>(); |
| 9116 | } |
| 9117 | |
| 9118 | Builder<STATE | TypeSet>& setType(Protocol::Runtime::ExecutionContextType in_type) |
| 9119 | { |
| 9120 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 9121 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 9122 | return castState<TypeSet>(); |
| 9123 | } |
| 9124 | |
| 9125 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 9126 | { |
| 9127 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 9128 | m_result->setString("name"_s , in_name); |
| 9129 | return castState<NameSet>(); |
| 9130 | } |
| 9131 | |
| 9132 | Builder<STATE | FrameIdSet>& setFrameId(const String& in_frameId) |
| 9133 | { |
| 9134 | COMPILE_ASSERT(!(STATE & FrameIdSet), property_frameId_already_set); |
| 9135 | m_result->setString("frameId"_s , in_frameId); |
| 9136 | return castState<FrameIdSet>(); |
| 9137 | } |
| 9138 | |
| 9139 | Ref<ExecutionContextDescription> release() |
| 9140 | { |
| 9141 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9142 | COMPILE_ASSERT(sizeof(ExecutionContextDescription) == sizeof(JSON::Object), cannot_cast); |
| 9143 | |
| 9144 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9145 | auto result = WTFMove(*reinterpret_cast<Ref<ExecutionContextDescription>*>(&jsonResult)); |
| 9146 | return result; |
| 9147 | } |
| 9148 | }; |
| 9149 | |
| 9150 | /* |
| 9151 | * Synthetic constructor: |
| 9152 | * Ref<ExecutionContextDescription> result = ExecutionContextDescription::create() |
| 9153 | * .setId(...) |
| 9154 | * .setType(...) |
| 9155 | * .setName(...) |
| 9156 | * .setFrameId(...) |
| 9157 | * .release(); |
| 9158 | */ |
| 9159 | static Builder<NoFieldsSet> create() |
| 9160 | { |
| 9161 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9162 | } |
| 9163 | }; |
| 9164 | |
| 9165 | /* Syntax error type: "none" for no error, "irrecoverable" for unrecoverable errors, "unterminated-literal" for when there is an unterminated literal, "recoverable" for when the expression is unfinished but valid so far. */ |
| 9166 | enum class SyntaxErrorType { |
| 9167 | None = 9, |
| 9168 | Irrecoverable = 209, |
| 9169 | UnterminatedLiteral = 210, |
| 9170 | Recoverable = 211, |
| 9171 | }; // enum class SyntaxErrorType |
| 9172 | |
| 9173 | /* Range of an error in source code. */ |
| 9174 | class ErrorRange final : public JSON::ObjectBase { |
| 9175 | public: |
| 9176 | enum { |
| 9177 | NoFieldsSet = 0, |
| 9178 | StartOffsetSet = 1 << 0, |
| 9179 | EndOffsetSet = 1 << 1, |
| 9180 | AllFieldsSet = (StartOffsetSet | EndOffsetSet) |
| 9181 | }; |
| 9182 | |
| 9183 | template<int STATE> |
| 9184 | class Builder { |
| 9185 | private: |
| 9186 | RefPtr<JSON::Object> m_result; |
| 9187 | |
| 9188 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9189 | { |
| 9190 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9191 | } |
| 9192 | |
| 9193 | Builder(Ref</*ErrorRange*/JSON::Object>&& object) |
| 9194 | : m_result(WTFMove(object)) |
| 9195 | { |
| 9196 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9197 | } |
| 9198 | friend class ErrorRange; |
| 9199 | public: |
| 9200 | |
| 9201 | Builder<STATE | StartOffsetSet>& setStartOffset(int in_startOffset) |
| 9202 | { |
| 9203 | COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set); |
| 9204 | m_result->setInteger("startOffset"_s , in_startOffset); |
| 9205 | return castState<StartOffsetSet>(); |
| 9206 | } |
| 9207 | |
| 9208 | Builder<STATE | EndOffsetSet>& setEndOffset(int in_endOffset) |
| 9209 | { |
| 9210 | COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set); |
| 9211 | m_result->setInteger("endOffset"_s , in_endOffset); |
| 9212 | return castState<EndOffsetSet>(); |
| 9213 | } |
| 9214 | |
| 9215 | Ref<ErrorRange> release() |
| 9216 | { |
| 9217 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9218 | COMPILE_ASSERT(sizeof(ErrorRange) == sizeof(JSON::Object), cannot_cast); |
| 9219 | |
| 9220 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9221 | auto result = WTFMove(*reinterpret_cast<Ref<ErrorRange>*>(&jsonResult)); |
| 9222 | return result; |
| 9223 | } |
| 9224 | }; |
| 9225 | |
| 9226 | /* |
| 9227 | * Synthetic constructor: |
| 9228 | * Ref<ErrorRange> result = ErrorRange::create() |
| 9229 | * .setStartOffset(...) |
| 9230 | * .setEndOffset(...) |
| 9231 | * .release(); |
| 9232 | */ |
| 9233 | static Builder<NoFieldsSet> create() |
| 9234 | { |
| 9235 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9236 | } |
| 9237 | }; |
| 9238 | |
| 9239 | class StructureDescription final : public JSON::ObjectBase { |
| 9240 | public: |
| 9241 | enum { |
| 9242 | NoFieldsSet = 0, |
| 9243 | AllFieldsSet = 0 |
| 9244 | }; |
| 9245 | |
| 9246 | template<int STATE> |
| 9247 | class Builder { |
| 9248 | private: |
| 9249 | RefPtr<JSON::Object> m_result; |
| 9250 | |
| 9251 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9252 | { |
| 9253 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9254 | } |
| 9255 | |
| 9256 | Builder(Ref</*StructureDescription*/JSON::Object>&& object) |
| 9257 | : m_result(WTFMove(object)) |
| 9258 | { |
| 9259 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9260 | } |
| 9261 | friend class StructureDescription; |
| 9262 | public: |
| 9263 | |
| 9264 | Ref<StructureDescription> release() |
| 9265 | { |
| 9266 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9267 | COMPILE_ASSERT(sizeof(StructureDescription) == sizeof(JSON::Object), cannot_cast); |
| 9268 | |
| 9269 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9270 | auto result = WTFMove(*reinterpret_cast<Ref<StructureDescription>*>(&jsonResult)); |
| 9271 | return result; |
| 9272 | } |
| 9273 | }; |
| 9274 | |
| 9275 | /* |
| 9276 | * Synthetic constructor: |
| 9277 | * Ref<StructureDescription> result = StructureDescription::create() |
| 9278 | * .release(); |
| 9279 | */ |
| 9280 | static Builder<NoFieldsSet> create() |
| 9281 | { |
| 9282 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9283 | } |
| 9284 | |
| 9285 | void setFields(Ref<JSON::ArrayOf<String>>&& in_opt_fields) |
| 9286 | { |
| 9287 | JSON::ObjectBase::setArray("fields"_s , WTFMove(in_opt_fields)); |
| 9288 | } |
| 9289 | |
| 9290 | void setOptionalFields(Ref<JSON::ArrayOf<String>>&& in_opt_optionalFields) |
| 9291 | { |
| 9292 | JSON::ObjectBase::setArray("optionalFields"_s , WTFMove(in_opt_optionalFields)); |
| 9293 | } |
| 9294 | |
| 9295 | void setConstructorName(const String& in_opt_constructorName) |
| 9296 | { |
| 9297 | JSON::ObjectBase::setString("constructorName"_s , in_opt_constructorName); |
| 9298 | } |
| 9299 | |
| 9300 | void setPrototypeStructure(Ref<Protocol::Runtime::StructureDescription>&& in_opt_prototypeStructure) |
| 9301 | { |
| 9302 | JSON::ObjectBase::setObject("prototypeStructure"_s , WTFMove(in_opt_prototypeStructure)); |
| 9303 | } |
| 9304 | |
| 9305 | void setIsImprecise(bool in_opt_isImprecise) |
| 9306 | { |
| 9307 | JSON::ObjectBase::setBoolean("isImprecise"_s , in_opt_isImprecise); |
| 9308 | } |
| 9309 | }; |
| 9310 | |
| 9311 | class TypeSet final : public JSON::ObjectBase { |
| 9312 | public: |
| 9313 | enum { |
| 9314 | NoFieldsSet = 0, |
| 9315 | IsFunctionSet = 1 << 0, |
| 9316 | IsUndefinedSet = 1 << 1, |
| 9317 | IsNullSet = 1 << 2, |
| 9318 | IsBooleanSet = 1 << 3, |
| 9319 | IsIntegerSet = 1 << 4, |
| 9320 | IsNumberSet = 1 << 5, |
| 9321 | IsStringSet = 1 << 6, |
| 9322 | IsObjectSet = 1 << 7, |
| 9323 | IsSymbolSet = 1 << 8, |
| 9324 | IsBigIntSet = 1 << 9, |
| 9325 | AllFieldsSet = (IsFunctionSet | IsUndefinedSet | IsNullSet | IsBooleanSet | IsIntegerSet | IsNumberSet | IsStringSet | IsObjectSet | IsSymbolSet | IsBigIntSet) |
| 9326 | }; |
| 9327 | |
| 9328 | template<int STATE> |
| 9329 | class Builder { |
| 9330 | private: |
| 9331 | RefPtr<JSON::Object> m_result; |
| 9332 | |
| 9333 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9334 | { |
| 9335 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9336 | } |
| 9337 | |
| 9338 | Builder(Ref</*TypeSet*/JSON::Object>&& object) |
| 9339 | : m_result(WTFMove(object)) |
| 9340 | { |
| 9341 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9342 | } |
| 9343 | friend class TypeSet; |
| 9344 | public: |
| 9345 | |
| 9346 | Builder<STATE | IsFunctionSet>& setIsFunction(bool in_isFunction) |
| 9347 | { |
| 9348 | COMPILE_ASSERT(!(STATE & IsFunctionSet), property_isFunction_already_set); |
| 9349 | m_result->setBoolean("isFunction"_s , in_isFunction); |
| 9350 | return castState<IsFunctionSet>(); |
| 9351 | } |
| 9352 | |
| 9353 | Builder<STATE | IsUndefinedSet>& setIsUndefined(bool in_isUndefined) |
| 9354 | { |
| 9355 | COMPILE_ASSERT(!(STATE & IsUndefinedSet), property_isUndefined_already_set); |
| 9356 | m_result->setBoolean("isUndefined"_s , in_isUndefined); |
| 9357 | return castState<IsUndefinedSet>(); |
| 9358 | } |
| 9359 | |
| 9360 | Builder<STATE | IsNullSet>& setIsNull(bool in_isNull) |
| 9361 | { |
| 9362 | COMPILE_ASSERT(!(STATE & IsNullSet), property_isNull_already_set); |
| 9363 | m_result->setBoolean("isNull"_s , in_isNull); |
| 9364 | return castState<IsNullSet>(); |
| 9365 | } |
| 9366 | |
| 9367 | Builder<STATE | IsBooleanSet>& setIsBoolean(bool in_isBoolean) |
| 9368 | { |
| 9369 | COMPILE_ASSERT(!(STATE & IsBooleanSet), property_isBoolean_already_set); |
| 9370 | m_result->setBoolean("isBoolean"_s , in_isBoolean); |
| 9371 | return castState<IsBooleanSet>(); |
| 9372 | } |
| 9373 | |
| 9374 | Builder<STATE | IsIntegerSet>& setIsInteger(bool in_isInteger) |
| 9375 | { |
| 9376 | COMPILE_ASSERT(!(STATE & IsIntegerSet), property_isInteger_already_set); |
| 9377 | m_result->setBoolean("isInteger"_s , in_isInteger); |
| 9378 | return castState<IsIntegerSet>(); |
| 9379 | } |
| 9380 | |
| 9381 | Builder<STATE | IsNumberSet>& setIsNumber(bool in_isNumber) |
| 9382 | { |
| 9383 | COMPILE_ASSERT(!(STATE & IsNumberSet), property_isNumber_already_set); |
| 9384 | m_result->setBoolean("isNumber"_s , in_isNumber); |
| 9385 | return castState<IsNumberSet>(); |
| 9386 | } |
| 9387 | |
| 9388 | Builder<STATE | IsStringSet>& setIsString(bool in_isString) |
| 9389 | { |
| 9390 | COMPILE_ASSERT(!(STATE & IsStringSet), property_isString_already_set); |
| 9391 | m_result->setBoolean("isString"_s , in_isString); |
| 9392 | return castState<IsStringSet>(); |
| 9393 | } |
| 9394 | |
| 9395 | Builder<STATE | IsObjectSet>& setIsObject(bool in_isObject) |
| 9396 | { |
| 9397 | COMPILE_ASSERT(!(STATE & IsObjectSet), property_isObject_already_set); |
| 9398 | m_result->setBoolean("isObject"_s , in_isObject); |
| 9399 | return castState<IsObjectSet>(); |
| 9400 | } |
| 9401 | |
| 9402 | Builder<STATE | IsSymbolSet>& setIsSymbol(bool in_isSymbol) |
| 9403 | { |
| 9404 | COMPILE_ASSERT(!(STATE & IsSymbolSet), property_isSymbol_already_set); |
| 9405 | m_result->setBoolean("isSymbol"_s , in_isSymbol); |
| 9406 | return castState<IsSymbolSet>(); |
| 9407 | } |
| 9408 | |
| 9409 | Builder<STATE | IsBigIntSet>& setIsBigInt(bool in_isBigInt) |
| 9410 | { |
| 9411 | COMPILE_ASSERT(!(STATE & IsBigIntSet), property_isBigInt_already_set); |
| 9412 | m_result->setBoolean("isBigInt"_s , in_isBigInt); |
| 9413 | return castState<IsBigIntSet>(); |
| 9414 | } |
| 9415 | |
| 9416 | Ref<TypeSet> release() |
| 9417 | { |
| 9418 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9419 | COMPILE_ASSERT(sizeof(TypeSet) == sizeof(JSON::Object), cannot_cast); |
| 9420 | |
| 9421 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9422 | auto result = WTFMove(*reinterpret_cast<Ref<TypeSet>*>(&jsonResult)); |
| 9423 | return result; |
| 9424 | } |
| 9425 | }; |
| 9426 | |
| 9427 | /* |
| 9428 | * Synthetic constructor: |
| 9429 | * Ref<TypeSet> result = TypeSet::create() |
| 9430 | * .setIsFunction(...) |
| 9431 | * .setIsUndefined(...) |
| 9432 | * .setIsNull(...) |
| 9433 | * .setIsBoolean(...) |
| 9434 | * .setIsInteger(...) |
| 9435 | * .setIsNumber(...) |
| 9436 | * .setIsString(...) |
| 9437 | * .setIsObject(...) |
| 9438 | * .setIsSymbol(...) |
| 9439 | * .setIsBigInt(...) |
| 9440 | * .release(); |
| 9441 | */ |
| 9442 | static Builder<NoFieldsSet> create() |
| 9443 | { |
| 9444 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9445 | } |
| 9446 | }; |
| 9447 | |
| 9448 | /* Container for type information that has been gathered. */ |
| 9449 | class TypeDescription final : public JSON::ObjectBase { |
| 9450 | public: |
| 9451 | enum { |
| 9452 | NoFieldsSet = 0, |
| 9453 | IsValidSet = 1 << 0, |
| 9454 | AllFieldsSet = (IsValidSet) |
| 9455 | }; |
| 9456 | |
| 9457 | template<int STATE> |
| 9458 | class Builder { |
| 9459 | private: |
| 9460 | RefPtr<JSON::Object> m_result; |
| 9461 | |
| 9462 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9463 | { |
| 9464 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9465 | } |
| 9466 | |
| 9467 | Builder(Ref</*TypeDescription*/JSON::Object>&& object) |
| 9468 | : m_result(WTFMove(object)) |
| 9469 | { |
| 9470 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9471 | } |
| 9472 | friend class TypeDescription; |
| 9473 | public: |
| 9474 | |
| 9475 | Builder<STATE | IsValidSet>& setIsValid(bool in_isValid) |
| 9476 | { |
| 9477 | COMPILE_ASSERT(!(STATE & IsValidSet), property_isValid_already_set); |
| 9478 | m_result->setBoolean("isValid"_s , in_isValid); |
| 9479 | return castState<IsValidSet>(); |
| 9480 | } |
| 9481 | |
| 9482 | Ref<TypeDescription> release() |
| 9483 | { |
| 9484 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9485 | COMPILE_ASSERT(sizeof(TypeDescription) == sizeof(JSON::Object), cannot_cast); |
| 9486 | |
| 9487 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9488 | auto result = WTFMove(*reinterpret_cast<Ref<TypeDescription>*>(&jsonResult)); |
| 9489 | return result; |
| 9490 | } |
| 9491 | }; |
| 9492 | |
| 9493 | /* |
| 9494 | * Synthetic constructor: |
| 9495 | * Ref<TypeDescription> result = TypeDescription::create() |
| 9496 | * .setIsValid(...) |
| 9497 | * .release(); |
| 9498 | */ |
| 9499 | static Builder<NoFieldsSet> create() |
| 9500 | { |
| 9501 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9502 | } |
| 9503 | |
| 9504 | void setLeastCommonAncestor(const String& in_opt_leastCommonAncestor) |
| 9505 | { |
| 9506 | JSON::ObjectBase::setString("leastCommonAncestor"_s , in_opt_leastCommonAncestor); |
| 9507 | } |
| 9508 | |
| 9509 | void setTypeSet(Ref<Protocol::Runtime::TypeSet>&& in_opt_typeSet) |
| 9510 | { |
| 9511 | JSON::ObjectBase::setObject("typeSet"_s , WTFMove(in_opt_typeSet)); |
| 9512 | } |
| 9513 | |
| 9514 | void setStructures(Ref<JSON::ArrayOf<Protocol::Runtime::StructureDescription>>&& in_opt_structures) |
| 9515 | { |
| 9516 | JSON::ObjectBase::setArray("structures"_s , WTFMove(in_opt_structures)); |
| 9517 | } |
| 9518 | |
| 9519 | void setIsTruncated(bool in_opt_isTruncated) |
| 9520 | { |
| 9521 | JSON::ObjectBase::setBoolean("isTruncated"_s , in_opt_isTruncated); |
| 9522 | } |
| 9523 | }; |
| 9524 | |
| 9525 | /* Describes the location of an expression we want type information for. */ |
| 9526 | class TypeLocation final : public JSON::Object { |
| 9527 | public: |
| 9528 | enum { |
| 9529 | NoFieldsSet = 0, |
| 9530 | TypeInformationDescriptorSet = 1 << 0, |
| 9531 | SourceIDSet = 1 << 1, |
| 9532 | DivotSet = 1 << 2, |
| 9533 | AllFieldsSet = (TypeInformationDescriptorSet | SourceIDSet | DivotSet) |
| 9534 | }; |
| 9535 | |
| 9536 | template<int STATE> |
| 9537 | class Builder { |
| 9538 | private: |
| 9539 | RefPtr<JSON::Object> m_result; |
| 9540 | |
| 9541 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9542 | { |
| 9543 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9544 | } |
| 9545 | |
| 9546 | Builder(Ref</*TypeLocation*/JSON::Object>&& object) |
| 9547 | : m_result(WTFMove(object)) |
| 9548 | { |
| 9549 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9550 | } |
| 9551 | friend class TypeLocation; |
| 9552 | public: |
| 9553 | |
| 9554 | Builder<STATE | TypeInformationDescriptorSet>& setTypeInformationDescriptor(int in_typeInformationDescriptor) |
| 9555 | { |
| 9556 | COMPILE_ASSERT(!(STATE & TypeInformationDescriptorSet), property_typeInformationDescriptor_already_set); |
| 9557 | m_result->setInteger("typeInformationDescriptor"_s , in_typeInformationDescriptor); |
| 9558 | return castState<TypeInformationDescriptorSet>(); |
| 9559 | } |
| 9560 | |
| 9561 | Builder<STATE | SourceIDSet>& setSourceID(const String& in_sourceID) |
| 9562 | { |
| 9563 | COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set); |
| 9564 | m_result->setString("sourceID"_s , in_sourceID); |
| 9565 | return castState<SourceIDSet>(); |
| 9566 | } |
| 9567 | |
| 9568 | Builder<STATE | DivotSet>& setDivot(int in_divot) |
| 9569 | { |
| 9570 | COMPILE_ASSERT(!(STATE & DivotSet), property_divot_already_set); |
| 9571 | m_result->setInteger("divot"_s , in_divot); |
| 9572 | return castState<DivotSet>(); |
| 9573 | } |
| 9574 | |
| 9575 | Ref<TypeLocation> release() |
| 9576 | { |
| 9577 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9578 | COMPILE_ASSERT(sizeof(TypeLocation) == sizeof(JSON::Object), cannot_cast); |
| 9579 | |
| 9580 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9581 | auto result = WTFMove(*reinterpret_cast<Ref<TypeLocation>*>(&jsonResult)); |
| 9582 | return result; |
| 9583 | } |
| 9584 | }; |
| 9585 | |
| 9586 | /* |
| 9587 | * Synthetic constructor: |
| 9588 | * Ref<TypeLocation> result = TypeLocation::create() |
| 9589 | * .setTypeInformationDescriptor(...) |
| 9590 | * .setSourceID(...) |
| 9591 | * .setDivot(...) |
| 9592 | * .release(); |
| 9593 | */ |
| 9594 | static Builder<NoFieldsSet> create() |
| 9595 | { |
| 9596 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9597 | } |
| 9598 | |
| 9599 | // Property names for type generated as open. |
| 9600 | JS_EXPORT_PRIVATE static const ASCIILiteral typeInformationDescriptorKey; |
| 9601 | JS_EXPORT_PRIVATE static const ASCIILiteral sourceIDKey; |
| 9602 | JS_EXPORT_PRIVATE static const ASCIILiteral divotKey; |
| 9603 | }; |
| 9604 | |
| 9605 | /* From Wikipedia: a basic block is a portion of the code within a program with only one entry point and only one exit point. This type gives the location of a basic block and if that basic block has executed. */ |
| 9606 | class BasicBlock final : public JSON::ObjectBase { |
| 9607 | public: |
| 9608 | enum { |
| 9609 | NoFieldsSet = 0, |
| 9610 | StartOffsetSet = 1 << 0, |
| 9611 | EndOffsetSet = 1 << 1, |
| 9612 | HasExecutedSet = 1 << 2, |
| 9613 | ExecutionCountSet = 1 << 3, |
| 9614 | AllFieldsSet = (StartOffsetSet | EndOffsetSet | HasExecutedSet | ExecutionCountSet) |
| 9615 | }; |
| 9616 | |
| 9617 | template<int STATE> |
| 9618 | class Builder { |
| 9619 | private: |
| 9620 | RefPtr<JSON::Object> m_result; |
| 9621 | |
| 9622 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9623 | { |
| 9624 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9625 | } |
| 9626 | |
| 9627 | Builder(Ref</*BasicBlock*/JSON::Object>&& object) |
| 9628 | : m_result(WTFMove(object)) |
| 9629 | { |
| 9630 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9631 | } |
| 9632 | friend class BasicBlock; |
| 9633 | public: |
| 9634 | |
| 9635 | Builder<STATE | StartOffsetSet>& setStartOffset(int in_startOffset) |
| 9636 | { |
| 9637 | COMPILE_ASSERT(!(STATE & StartOffsetSet), property_startOffset_already_set); |
| 9638 | m_result->setInteger("startOffset"_s , in_startOffset); |
| 9639 | return castState<StartOffsetSet>(); |
| 9640 | } |
| 9641 | |
| 9642 | Builder<STATE | EndOffsetSet>& setEndOffset(int in_endOffset) |
| 9643 | { |
| 9644 | COMPILE_ASSERT(!(STATE & EndOffsetSet), property_endOffset_already_set); |
| 9645 | m_result->setInteger("endOffset"_s , in_endOffset); |
| 9646 | return castState<EndOffsetSet>(); |
| 9647 | } |
| 9648 | |
| 9649 | Builder<STATE | HasExecutedSet>& setHasExecuted(bool in_hasExecuted) |
| 9650 | { |
| 9651 | COMPILE_ASSERT(!(STATE & HasExecutedSet), property_hasExecuted_already_set); |
| 9652 | m_result->setBoolean("hasExecuted"_s , in_hasExecuted); |
| 9653 | return castState<HasExecutedSet>(); |
| 9654 | } |
| 9655 | |
| 9656 | Builder<STATE | ExecutionCountSet>& setExecutionCount(int in_executionCount) |
| 9657 | { |
| 9658 | COMPILE_ASSERT(!(STATE & ExecutionCountSet), property_executionCount_already_set); |
| 9659 | m_result->setInteger("executionCount"_s , in_executionCount); |
| 9660 | return castState<ExecutionCountSet>(); |
| 9661 | } |
| 9662 | |
| 9663 | Ref<BasicBlock> release() |
| 9664 | { |
| 9665 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9666 | COMPILE_ASSERT(sizeof(BasicBlock) == sizeof(JSON::Object), cannot_cast); |
| 9667 | |
| 9668 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9669 | auto result = WTFMove(*reinterpret_cast<Ref<BasicBlock>*>(&jsonResult)); |
| 9670 | return result; |
| 9671 | } |
| 9672 | }; |
| 9673 | |
| 9674 | /* |
| 9675 | * Synthetic constructor: |
| 9676 | * Ref<BasicBlock> result = BasicBlock::create() |
| 9677 | * .setStartOffset(...) |
| 9678 | * .setEndOffset(...) |
| 9679 | * .setHasExecuted(...) |
| 9680 | * .setExecutionCount(...) |
| 9681 | * .release(); |
| 9682 | */ |
| 9683 | static Builder<NoFieldsSet> create() |
| 9684 | { |
| 9685 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9686 | } |
| 9687 | }; |
| 9688 | |
| 9689 | } // Runtime |
| 9690 | |
| 9691 | namespace ScriptProfiler { |
| 9692 | |
| 9693 | enum class EventType { |
| 9694 | API = 212, |
| 9695 | Microtask = 213, |
| 9696 | Other = 157, |
| 9697 | }; // enum class EventType |
| 9698 | |
| 9699 | class Event final : public JSON::ObjectBase { |
| 9700 | public: |
| 9701 | enum { |
| 9702 | NoFieldsSet = 0, |
| 9703 | StartTimeSet = 1 << 0, |
| 9704 | EndTimeSet = 1 << 1, |
| 9705 | TypeSet = 1 << 2, |
| 9706 | AllFieldsSet = (StartTimeSet | EndTimeSet | TypeSet) |
| 9707 | }; |
| 9708 | |
| 9709 | template<int STATE> |
| 9710 | class Builder { |
| 9711 | private: |
| 9712 | RefPtr<JSON::Object> m_result; |
| 9713 | |
| 9714 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9715 | { |
| 9716 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9717 | } |
| 9718 | |
| 9719 | Builder(Ref</*Event*/JSON::Object>&& object) |
| 9720 | : m_result(WTFMove(object)) |
| 9721 | { |
| 9722 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9723 | } |
| 9724 | friend class Event; |
| 9725 | public: |
| 9726 | |
| 9727 | Builder<STATE | StartTimeSet>& setStartTime(double in_startTime) |
| 9728 | { |
| 9729 | COMPILE_ASSERT(!(STATE & StartTimeSet), property_startTime_already_set); |
| 9730 | m_result->setDouble("startTime"_s , in_startTime); |
| 9731 | return castState<StartTimeSet>(); |
| 9732 | } |
| 9733 | |
| 9734 | Builder<STATE | EndTimeSet>& setEndTime(double in_endTime) |
| 9735 | { |
| 9736 | COMPILE_ASSERT(!(STATE & EndTimeSet), property_endTime_already_set); |
| 9737 | m_result->setDouble("endTime"_s , in_endTime); |
| 9738 | return castState<EndTimeSet>(); |
| 9739 | } |
| 9740 | |
| 9741 | Builder<STATE | TypeSet>& setType(Protocol::ScriptProfiler::EventType in_type) |
| 9742 | { |
| 9743 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 9744 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 9745 | return castState<TypeSet>(); |
| 9746 | } |
| 9747 | |
| 9748 | Ref<Event> release() |
| 9749 | { |
| 9750 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9751 | COMPILE_ASSERT(sizeof(Event) == sizeof(JSON::Object), cannot_cast); |
| 9752 | |
| 9753 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9754 | auto result = WTFMove(*reinterpret_cast<Ref<Event>*>(&jsonResult)); |
| 9755 | return result; |
| 9756 | } |
| 9757 | }; |
| 9758 | |
| 9759 | /* |
| 9760 | * Synthetic constructor: |
| 9761 | * Ref<Event> result = Event::create() |
| 9762 | * .setStartTime(...) |
| 9763 | * .setEndTime(...) |
| 9764 | * .setType(...) |
| 9765 | * .release(); |
| 9766 | */ |
| 9767 | static Builder<NoFieldsSet> create() |
| 9768 | { |
| 9769 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9770 | } |
| 9771 | }; |
| 9772 | |
| 9773 | class ExpressionLocation final : public JSON::ObjectBase { |
| 9774 | public: |
| 9775 | enum { |
| 9776 | NoFieldsSet = 0, |
| 9777 | LineSet = 1 << 0, |
| 9778 | ColumnSet = 1 << 1, |
| 9779 | AllFieldsSet = (LineSet | ColumnSet) |
| 9780 | }; |
| 9781 | |
| 9782 | template<int STATE> |
| 9783 | class Builder { |
| 9784 | private: |
| 9785 | RefPtr<JSON::Object> m_result; |
| 9786 | |
| 9787 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9788 | { |
| 9789 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9790 | } |
| 9791 | |
| 9792 | Builder(Ref</*ExpressionLocation*/JSON::Object>&& object) |
| 9793 | : m_result(WTFMove(object)) |
| 9794 | { |
| 9795 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9796 | } |
| 9797 | friend class ExpressionLocation; |
| 9798 | public: |
| 9799 | |
| 9800 | Builder<STATE | LineSet>& setLine(int in_line) |
| 9801 | { |
| 9802 | COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set); |
| 9803 | m_result->setInteger("line"_s , in_line); |
| 9804 | return castState<LineSet>(); |
| 9805 | } |
| 9806 | |
| 9807 | Builder<STATE | ColumnSet>& setColumn(int in_column) |
| 9808 | { |
| 9809 | COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set); |
| 9810 | m_result->setInteger("column"_s , in_column); |
| 9811 | return castState<ColumnSet>(); |
| 9812 | } |
| 9813 | |
| 9814 | Ref<ExpressionLocation> release() |
| 9815 | { |
| 9816 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9817 | COMPILE_ASSERT(sizeof(ExpressionLocation) == sizeof(JSON::Object), cannot_cast); |
| 9818 | |
| 9819 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9820 | auto result = WTFMove(*reinterpret_cast<Ref<ExpressionLocation>*>(&jsonResult)); |
| 9821 | return result; |
| 9822 | } |
| 9823 | }; |
| 9824 | |
| 9825 | /* |
| 9826 | * Synthetic constructor: |
| 9827 | * Ref<ExpressionLocation> result = ExpressionLocation::create() |
| 9828 | * .setLine(...) |
| 9829 | * .setColumn(...) |
| 9830 | * .release(); |
| 9831 | */ |
| 9832 | static Builder<NoFieldsSet> create() |
| 9833 | { |
| 9834 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9835 | } |
| 9836 | }; |
| 9837 | |
| 9838 | class StackFrame final : public JSON::ObjectBase { |
| 9839 | public: |
| 9840 | enum { |
| 9841 | NoFieldsSet = 0, |
| 9842 | SourceIDSet = 1 << 0, |
| 9843 | NameSet = 1 << 1, |
| 9844 | LineSet = 1 << 2, |
| 9845 | ColumnSet = 1 << 3, |
| 9846 | UrlSet = 1 << 4, |
| 9847 | AllFieldsSet = (SourceIDSet | NameSet | LineSet | ColumnSet | UrlSet) |
| 9848 | }; |
| 9849 | |
| 9850 | template<int STATE> |
| 9851 | class Builder { |
| 9852 | private: |
| 9853 | RefPtr<JSON::Object> m_result; |
| 9854 | |
| 9855 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9856 | { |
| 9857 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9858 | } |
| 9859 | |
| 9860 | Builder(Ref</*StackFrame*/JSON::Object>&& object) |
| 9861 | : m_result(WTFMove(object)) |
| 9862 | { |
| 9863 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9864 | } |
| 9865 | friend class StackFrame; |
| 9866 | public: |
| 9867 | |
| 9868 | Builder<STATE | SourceIDSet>& setSourceID(const String& in_sourceID) |
| 9869 | { |
| 9870 | COMPILE_ASSERT(!(STATE & SourceIDSet), property_sourceID_already_set); |
| 9871 | m_result->setString("sourceID"_s , in_sourceID); |
| 9872 | return castState<SourceIDSet>(); |
| 9873 | } |
| 9874 | |
| 9875 | Builder<STATE | NameSet>& setName(const String& in_name) |
| 9876 | { |
| 9877 | COMPILE_ASSERT(!(STATE & NameSet), property_name_already_set); |
| 9878 | m_result->setString("name"_s , in_name); |
| 9879 | return castState<NameSet>(); |
| 9880 | } |
| 9881 | |
| 9882 | Builder<STATE | LineSet>& setLine(int in_line) |
| 9883 | { |
| 9884 | COMPILE_ASSERT(!(STATE & LineSet), property_line_already_set); |
| 9885 | m_result->setInteger("line"_s , in_line); |
| 9886 | return castState<LineSet>(); |
| 9887 | } |
| 9888 | |
| 9889 | Builder<STATE | ColumnSet>& setColumn(int in_column) |
| 9890 | { |
| 9891 | COMPILE_ASSERT(!(STATE & ColumnSet), property_column_already_set); |
| 9892 | m_result->setInteger("column"_s , in_column); |
| 9893 | return castState<ColumnSet>(); |
| 9894 | } |
| 9895 | |
| 9896 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 9897 | { |
| 9898 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 9899 | m_result->setString("url"_s , in_url); |
| 9900 | return castState<UrlSet>(); |
| 9901 | } |
| 9902 | |
| 9903 | Ref<StackFrame> release() |
| 9904 | { |
| 9905 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9906 | COMPILE_ASSERT(sizeof(StackFrame) == sizeof(JSON::Object), cannot_cast); |
| 9907 | |
| 9908 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9909 | auto result = WTFMove(*reinterpret_cast<Ref<StackFrame>*>(&jsonResult)); |
| 9910 | return result; |
| 9911 | } |
| 9912 | }; |
| 9913 | |
| 9914 | /* |
| 9915 | * Synthetic constructor: |
| 9916 | * Ref<StackFrame> result = StackFrame::create() |
| 9917 | * .setSourceID(...) |
| 9918 | * .setName(...) |
| 9919 | * .setLine(...) |
| 9920 | * .setColumn(...) |
| 9921 | * .setUrl(...) |
| 9922 | * .release(); |
| 9923 | */ |
| 9924 | static Builder<NoFieldsSet> create() |
| 9925 | { |
| 9926 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9927 | } |
| 9928 | |
| 9929 | void setExpressionLocation(Ref<Protocol::ScriptProfiler::ExpressionLocation>&& in_opt_expressionLocation) |
| 9930 | { |
| 9931 | JSON::ObjectBase::setObject("expressionLocation"_s , WTFMove(in_opt_expressionLocation)); |
| 9932 | } |
| 9933 | }; |
| 9934 | |
| 9935 | class StackTrace final : public JSON::ObjectBase { |
| 9936 | public: |
| 9937 | enum { |
| 9938 | NoFieldsSet = 0, |
| 9939 | TimestampSet = 1 << 0, |
| 9940 | StackFramesSet = 1 << 1, |
| 9941 | AllFieldsSet = (TimestampSet | StackFramesSet) |
| 9942 | }; |
| 9943 | |
| 9944 | template<int STATE> |
| 9945 | class Builder { |
| 9946 | private: |
| 9947 | RefPtr<JSON::Object> m_result; |
| 9948 | |
| 9949 | template<int STEP> Builder<STATE | STEP>& castState() |
| 9950 | { |
| 9951 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 9952 | } |
| 9953 | |
| 9954 | Builder(Ref</*StackTrace*/JSON::Object>&& object) |
| 9955 | : m_result(WTFMove(object)) |
| 9956 | { |
| 9957 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 9958 | } |
| 9959 | friend class StackTrace; |
| 9960 | public: |
| 9961 | |
| 9962 | Builder<STATE | TimestampSet>& setTimestamp(double in_timestamp) |
| 9963 | { |
| 9964 | COMPILE_ASSERT(!(STATE & TimestampSet), property_timestamp_already_set); |
| 9965 | m_result->setDouble("timestamp"_s , in_timestamp); |
| 9966 | return castState<TimestampSet>(); |
| 9967 | } |
| 9968 | |
| 9969 | Builder<STATE | StackFramesSet>& setStackFrames(Ref<JSON::ArrayOf<Protocol::ScriptProfiler::StackFrame>>&& in_stackFrames) |
| 9970 | { |
| 9971 | COMPILE_ASSERT(!(STATE & StackFramesSet), property_stackFrames_already_set); |
| 9972 | m_result->setArray("stackFrames"_s , WTFMove(in_stackFrames)); |
| 9973 | return castState<StackFramesSet>(); |
| 9974 | } |
| 9975 | |
| 9976 | Ref<StackTrace> release() |
| 9977 | { |
| 9978 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 9979 | COMPILE_ASSERT(sizeof(StackTrace) == sizeof(JSON::Object), cannot_cast); |
| 9980 | |
| 9981 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 9982 | auto result = WTFMove(*reinterpret_cast<Ref<StackTrace>*>(&jsonResult)); |
| 9983 | return result; |
| 9984 | } |
| 9985 | }; |
| 9986 | |
| 9987 | /* |
| 9988 | * Synthetic constructor: |
| 9989 | * Ref<StackTrace> result = StackTrace::create() |
| 9990 | * .setTimestamp(...) |
| 9991 | * .setStackFrames(...) |
| 9992 | * .release(); |
| 9993 | */ |
| 9994 | static Builder<NoFieldsSet> create() |
| 9995 | { |
| 9996 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 9997 | } |
| 9998 | }; |
| 9999 | |
| 10000 | class Samples final : public JSON::ObjectBase { |
| 10001 | public: |
| 10002 | enum { |
| 10003 | NoFieldsSet = 0, |
| 10004 | StackTracesSet = 1 << 0, |
| 10005 | AllFieldsSet = (StackTracesSet) |
| 10006 | }; |
| 10007 | |
| 10008 | template<int STATE> |
| 10009 | class Builder { |
| 10010 | private: |
| 10011 | RefPtr<JSON::Object> m_result; |
| 10012 | |
| 10013 | template<int STEP> Builder<STATE | STEP>& castState() |
| 10014 | { |
| 10015 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 10016 | } |
| 10017 | |
| 10018 | Builder(Ref</*Samples*/JSON::Object>&& object) |
| 10019 | : m_result(WTFMove(object)) |
| 10020 | { |
| 10021 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 10022 | } |
| 10023 | friend class Samples; |
| 10024 | public: |
| 10025 | |
| 10026 | Builder<STATE | StackTracesSet>& setStackTraces(Ref<JSON::ArrayOf<Protocol::ScriptProfiler::StackTrace>>&& in_stackTraces) |
| 10027 | { |
| 10028 | COMPILE_ASSERT(!(STATE & StackTracesSet), property_stackTraces_already_set); |
| 10029 | m_result->setArray("stackTraces"_s , WTFMove(in_stackTraces)); |
| 10030 | return castState<StackTracesSet>(); |
| 10031 | } |
| 10032 | |
| 10033 | Ref<Samples> release() |
| 10034 | { |
| 10035 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 10036 | COMPILE_ASSERT(sizeof(Samples) == sizeof(JSON::Object), cannot_cast); |
| 10037 | |
| 10038 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 10039 | auto result = WTFMove(*reinterpret_cast<Ref<Samples>*>(&jsonResult)); |
| 10040 | return result; |
| 10041 | } |
| 10042 | }; |
| 10043 | |
| 10044 | /* |
| 10045 | * Synthetic constructor: |
| 10046 | * Ref<Samples> result = Samples::create() |
| 10047 | * .setStackTraces(...) |
| 10048 | * .release(); |
| 10049 | */ |
| 10050 | static Builder<NoFieldsSet> create() |
| 10051 | { |
| 10052 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 10053 | } |
| 10054 | }; |
| 10055 | |
| 10056 | } // ScriptProfiler |
| 10057 | |
| 10058 | namespace Security { |
| 10059 | |
| 10060 | /* Information about a SSL connection to display in the frontend. */ |
| 10061 | class Connection final : public JSON::ObjectBase { |
| 10062 | public: |
| 10063 | enum { |
| 10064 | NoFieldsSet = 0, |
| 10065 | AllFieldsSet = 0 |
| 10066 | }; |
| 10067 | |
| 10068 | template<int STATE> |
| 10069 | class Builder { |
| 10070 | private: |
| 10071 | RefPtr<JSON::Object> m_result; |
| 10072 | |
| 10073 | template<int STEP> Builder<STATE | STEP>& castState() |
| 10074 | { |
| 10075 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 10076 | } |
| 10077 | |
| 10078 | Builder(Ref</*Connection*/JSON::Object>&& object) |
| 10079 | : m_result(WTFMove(object)) |
| 10080 | { |
| 10081 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 10082 | } |
| 10083 | friend class Connection; |
| 10084 | public: |
| 10085 | |
| 10086 | Ref<Connection> release() |
| 10087 | { |
| 10088 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 10089 | COMPILE_ASSERT(sizeof(Connection) == sizeof(JSON::Object), cannot_cast); |
| 10090 | |
| 10091 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 10092 | auto result = WTFMove(*reinterpret_cast<Ref<Connection>*>(&jsonResult)); |
| 10093 | return result; |
| 10094 | } |
| 10095 | }; |
| 10096 | |
| 10097 | /* |
| 10098 | * Synthetic constructor: |
| 10099 | * Ref<Connection> result = Connection::create() |
| 10100 | * .release(); |
| 10101 | */ |
| 10102 | static Builder<NoFieldsSet> create() |
| 10103 | { |
| 10104 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 10105 | } |
| 10106 | |
| 10107 | void setProtocol(const String& in_opt_protocol) |
| 10108 | { |
| 10109 | JSON::ObjectBase::setString("protocol"_s , in_opt_protocol); |
| 10110 | } |
| 10111 | |
| 10112 | void setCipher(const String& in_opt_cipher) |
| 10113 | { |
| 10114 | JSON::ObjectBase::setString("cipher"_s , in_opt_cipher); |
| 10115 | } |
| 10116 | }; |
| 10117 | |
| 10118 | /* Information about a SSL certificate to display in the frontend. */ |
| 10119 | class Certificate final : public JSON::ObjectBase { |
| 10120 | public: |
| 10121 | enum { |
| 10122 | NoFieldsSet = 0, |
| 10123 | AllFieldsSet = 0 |
| 10124 | }; |
| 10125 | |
| 10126 | template<int STATE> |
| 10127 | class Builder { |
| 10128 | private: |
| 10129 | RefPtr<JSON::Object> m_result; |
| 10130 | |
| 10131 | template<int STEP> Builder<STATE | STEP>& castState() |
| 10132 | { |
| 10133 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 10134 | } |
| 10135 | |
| 10136 | Builder(Ref</*Certificate*/JSON::Object>&& object) |
| 10137 | : m_result(WTFMove(object)) |
| 10138 | { |
| 10139 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 10140 | } |
| 10141 | friend class Certificate; |
| 10142 | public: |
| 10143 | |
| 10144 | Ref<Certificate> release() |
| 10145 | { |
| 10146 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 10147 | COMPILE_ASSERT(sizeof(Certificate) == sizeof(JSON::Object), cannot_cast); |
| 10148 | |
| 10149 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 10150 | auto result = WTFMove(*reinterpret_cast<Ref<Certificate>*>(&jsonResult)); |
| 10151 | return result; |
| 10152 | } |
| 10153 | }; |
| 10154 | |
| 10155 | /* |
| 10156 | * Synthetic constructor: |
| 10157 | * Ref<Certificate> result = Certificate::create() |
| 10158 | * .release(); |
| 10159 | */ |
| 10160 | static Builder<NoFieldsSet> create() |
| 10161 | { |
| 10162 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 10163 | } |
| 10164 | |
| 10165 | void setSubject(const String& in_opt_subject) |
| 10166 | { |
| 10167 | JSON::ObjectBase::setString("subject"_s , in_opt_subject); |
| 10168 | } |
| 10169 | |
| 10170 | void setValidFrom(double in_opt_validFrom) |
| 10171 | { |
| 10172 | JSON::ObjectBase::setDouble("validFrom"_s , in_opt_validFrom); |
| 10173 | } |
| 10174 | |
| 10175 | void setValidUntil(double in_opt_validUntil) |
| 10176 | { |
| 10177 | JSON::ObjectBase::setDouble("validUntil"_s , in_opt_validUntil); |
| 10178 | } |
| 10179 | |
| 10180 | void setDnsNames(Ref<JSON::ArrayOf<String>>&& in_opt_dnsNames) |
| 10181 | { |
| 10182 | JSON::ObjectBase::setArray("dnsNames"_s , WTFMove(in_opt_dnsNames)); |
| 10183 | } |
| 10184 | |
| 10185 | void setIpAddresses(Ref<JSON::ArrayOf<String>>&& in_opt_ipAddresses) |
| 10186 | { |
| 10187 | JSON::ObjectBase::setArray("ipAddresses"_s , WTFMove(in_opt_ipAddresses)); |
| 10188 | } |
| 10189 | }; |
| 10190 | |
| 10191 | /* Security information for a given Network.Response. */ |
| 10192 | class Security final : public JSON::ObjectBase { |
| 10193 | public: |
| 10194 | enum { |
| 10195 | NoFieldsSet = 0, |
| 10196 | AllFieldsSet = 0 |
| 10197 | }; |
| 10198 | |
| 10199 | template<int STATE> |
| 10200 | class Builder { |
| 10201 | private: |
| 10202 | RefPtr<JSON::Object> m_result; |
| 10203 | |
| 10204 | template<int STEP> Builder<STATE | STEP>& castState() |
| 10205 | { |
| 10206 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 10207 | } |
| 10208 | |
| 10209 | Builder(Ref</*Security*/JSON::Object>&& object) |
| 10210 | : m_result(WTFMove(object)) |
| 10211 | { |
| 10212 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 10213 | } |
| 10214 | friend class Security; |
| 10215 | public: |
| 10216 | |
| 10217 | Ref<Security> release() |
| 10218 | { |
| 10219 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 10220 | COMPILE_ASSERT(sizeof(Security) == sizeof(JSON::Object), cannot_cast); |
| 10221 | |
| 10222 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 10223 | auto result = WTFMove(*reinterpret_cast<Ref<Security>*>(&jsonResult)); |
| 10224 | return result; |
| 10225 | } |
| 10226 | }; |
| 10227 | |
| 10228 | /* |
| 10229 | * Synthetic constructor: |
| 10230 | * Ref<Security> result = Security::create() |
| 10231 | * .release(); |
| 10232 | */ |
| 10233 | static Builder<NoFieldsSet> create() |
| 10234 | { |
| 10235 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 10236 | } |
| 10237 | |
| 10238 | void setConnection(Ref<Protocol::Security::Connection>&& in_opt_connection) |
| 10239 | { |
| 10240 | JSON::ObjectBase::setObject("connection"_s , WTFMove(in_opt_connection)); |
| 10241 | } |
| 10242 | |
| 10243 | void setCertificate(Ref<Protocol::Security::Certificate>&& in_opt_certificate) |
| 10244 | { |
| 10245 | JSON::ObjectBase::setObject("certificate"_s , WTFMove(in_opt_certificate)); |
| 10246 | } |
| 10247 | }; |
| 10248 | |
| 10249 | } // Security |
| 10250 | |
| 10251 | #if defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER |
| 10252 | namespace ServiceWorker { |
| 10253 | |
| 10254 | /* ServiceWorker metadata and initial state. */ |
| 10255 | class Configuration final : public JSON::ObjectBase { |
| 10256 | public: |
| 10257 | enum { |
| 10258 | NoFieldsSet = 0, |
| 10259 | TargetIdSet = 1 << 0, |
| 10260 | SecurityOriginSet = 1 << 1, |
| 10261 | UrlSet = 1 << 2, |
| 10262 | ContentSet = 1 << 3, |
| 10263 | AllFieldsSet = (TargetIdSet | SecurityOriginSet | UrlSet | ContentSet) |
| 10264 | }; |
| 10265 | |
| 10266 | template<int STATE> |
| 10267 | class Builder { |
| 10268 | private: |
| 10269 | RefPtr<JSON::Object> m_result; |
| 10270 | |
| 10271 | template<int STEP> Builder<STATE | STEP>& castState() |
| 10272 | { |
| 10273 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 10274 | } |
| 10275 | |
| 10276 | Builder(Ref</*Configuration*/JSON::Object>&& object) |
| 10277 | : m_result(WTFMove(object)) |
| 10278 | { |
| 10279 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 10280 | } |
| 10281 | friend class Configuration; |
| 10282 | public: |
| 10283 | |
| 10284 | Builder<STATE | TargetIdSet>& setTargetId(const String& in_targetId) |
| 10285 | { |
| 10286 | COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set); |
| 10287 | m_result->setString("targetId"_s , in_targetId); |
| 10288 | return castState<TargetIdSet>(); |
| 10289 | } |
| 10290 | |
| 10291 | Builder<STATE | SecurityOriginSet>& setSecurityOrigin(const String& in_securityOrigin) |
| 10292 | { |
| 10293 | COMPILE_ASSERT(!(STATE & SecurityOriginSet), property_securityOrigin_already_set); |
| 10294 | m_result->setString("securityOrigin"_s , in_securityOrigin); |
| 10295 | return castState<SecurityOriginSet>(); |
| 10296 | } |
| 10297 | |
| 10298 | Builder<STATE | UrlSet>& setUrl(const String& in_url) |
| 10299 | { |
| 10300 | COMPILE_ASSERT(!(STATE & UrlSet), property_url_already_set); |
| 10301 | m_result->setString("url"_s , in_url); |
| 10302 | return castState<UrlSet>(); |
| 10303 | } |
| 10304 | |
| 10305 | Builder<STATE | ContentSet>& setContent(const String& in_content) |
| 10306 | { |
| 10307 | COMPILE_ASSERT(!(STATE & ContentSet), property_content_already_set); |
| 10308 | m_result->setString("content"_s , in_content); |
| 10309 | return castState<ContentSet>(); |
| 10310 | } |
| 10311 | |
| 10312 | Ref<Configuration> release() |
| 10313 | { |
| 10314 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 10315 | COMPILE_ASSERT(sizeof(Configuration) == sizeof(JSON::Object), cannot_cast); |
| 10316 | |
| 10317 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 10318 | auto result = WTFMove(*reinterpret_cast<Ref<Configuration>*>(&jsonResult)); |
| 10319 | return result; |
| 10320 | } |
| 10321 | }; |
| 10322 | |
| 10323 | /* |
| 10324 | * Synthetic constructor: |
| 10325 | * Ref<Configuration> result = Configuration::create() |
| 10326 | * .setTargetId(...) |
| 10327 | * .setSecurityOrigin(...) |
| 10328 | * .setUrl(...) |
| 10329 | * .setContent(...) |
| 10330 | * .release(); |
| 10331 | */ |
| 10332 | static Builder<NoFieldsSet> create() |
| 10333 | { |
| 10334 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 10335 | } |
| 10336 | }; |
| 10337 | |
| 10338 | } // ServiceWorker |
| 10339 | #endif // defined(ENABLE_SERVICE_WORKER) && ENABLE_SERVICE_WORKER |
| 10340 | |
| 10341 | namespace Target { |
| 10342 | |
| 10343 | /* Description of a target. */ |
| 10344 | class TargetInfo final : public JSON::ObjectBase { |
| 10345 | public: |
| 10346 | // Named after property name 'type' while generating TargetInfo. |
| 10347 | enum class Type { |
| 10348 | Page = 104, |
| 10349 | ServiceWorker = 142, |
| 10350 | Worker = 214, |
| 10351 | }; // enum class Type |
| 10352 | |
| 10353 | enum { |
| 10354 | NoFieldsSet = 0, |
| 10355 | TargetIdSet = 1 << 0, |
| 10356 | TypeSet = 1 << 1, |
| 10357 | AllFieldsSet = (TargetIdSet | TypeSet) |
| 10358 | }; |
| 10359 | |
| 10360 | template<int STATE> |
| 10361 | class Builder { |
| 10362 | private: |
| 10363 | RefPtr<JSON::Object> m_result; |
| 10364 | |
| 10365 | template<int STEP> Builder<STATE | STEP>& castState() |
| 10366 | { |
| 10367 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 10368 | } |
| 10369 | |
| 10370 | Builder(Ref</*TargetInfo*/JSON::Object>&& object) |
| 10371 | : m_result(WTFMove(object)) |
| 10372 | { |
| 10373 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 10374 | } |
| 10375 | friend class TargetInfo; |
| 10376 | public: |
| 10377 | |
| 10378 | Builder<STATE | TargetIdSet>& setTargetId(const String& in_targetId) |
| 10379 | { |
| 10380 | COMPILE_ASSERT(!(STATE & TargetIdSet), property_targetId_already_set); |
| 10381 | m_result->setString("targetId"_s , in_targetId); |
| 10382 | return castState<TargetIdSet>(); |
| 10383 | } |
| 10384 | |
| 10385 | Builder<STATE | TypeSet>& setType(Type in_type) |
| 10386 | { |
| 10387 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 10388 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 10389 | return castState<TypeSet>(); |
| 10390 | } |
| 10391 | |
| 10392 | Ref<TargetInfo> release() |
| 10393 | { |
| 10394 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 10395 | COMPILE_ASSERT(sizeof(TargetInfo) == sizeof(JSON::Object), cannot_cast); |
| 10396 | |
| 10397 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 10398 | auto result = WTFMove(*reinterpret_cast<Ref<TargetInfo>*>(&jsonResult)); |
| 10399 | return result; |
| 10400 | } |
| 10401 | }; |
| 10402 | |
| 10403 | /* |
| 10404 | * Synthetic constructor: |
| 10405 | * Ref<TargetInfo> result = TargetInfo::create() |
| 10406 | * .setTargetId(...) |
| 10407 | * .setType(...) |
| 10408 | * .release(); |
| 10409 | */ |
| 10410 | static Builder<NoFieldsSet> create() |
| 10411 | { |
| 10412 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 10413 | } |
| 10414 | |
| 10415 | void setIsProvisional(bool in_opt_isProvisional) |
| 10416 | { |
| 10417 | JSON::ObjectBase::setBoolean("isProvisional"_s , in_opt_isProvisional); |
| 10418 | } |
| 10419 | |
| 10420 | void setIsPaused(bool in_opt_isPaused) |
| 10421 | { |
| 10422 | JSON::ObjectBase::setBoolean("isPaused"_s , in_opt_isPaused); |
| 10423 | } |
| 10424 | }; |
| 10425 | |
| 10426 | } // Target |
| 10427 | |
| 10428 | namespace Timeline { |
| 10429 | |
| 10430 | /* Timeline record type. */ |
| 10431 | enum class EventType { |
| 10432 | EventDispatch = 215, |
| 10433 | ScheduleStyleRecalculation = 216, |
| 10434 | RecalculateStyles = 217, |
| 10435 | InvalidateLayout = 218, |
| 10436 | Layout = 219, |
| 10437 | Paint = 220, |
| 10438 | Composite = 221, |
| 10439 | RenderingFrame = 222, |
| 10440 | TimerInstall = 223, |
| 10441 | TimerRemove = 224, |
| 10442 | TimerFire = 225, |
| 10443 | EvaluateScript = 226, |
| 10444 | TimeStamp = 227, |
| 10445 | Time = 228, |
| 10446 | TimeEnd = 229, |
| 10447 | FunctionCall = 230, |
| 10448 | ProbeSample = 231, |
| 10449 | ConsoleProfile = 232, |
| 10450 | RequestAnimationFrame = 233, |
| 10451 | CancelAnimationFrame = 234, |
| 10452 | FireAnimationFrame = 235, |
| 10453 | ObserverCallback = 236, |
| 10454 | }; // enum class EventType |
| 10455 | |
| 10456 | /* Instrument types. */ |
| 10457 | enum class Instrument { |
| 10458 | ScriptProfiler = 237, |
| 10459 | Timeline = 238, |
| 10460 | CPU = 239, |
| 10461 | Memory = 240, |
| 10462 | Heap = 241, |
| 10463 | Animation = 242, |
| 10464 | }; // enum class Instrument |
| 10465 | |
| 10466 | /* Timeline record contains information about the recorded activity. */ |
| 10467 | class TimelineEvent final : public JSON::Object { |
| 10468 | public: |
| 10469 | enum { |
| 10470 | NoFieldsSet = 0, |
| 10471 | TypeSet = 1 << 0, |
| 10472 | DataSet = 1 << 1, |
| 10473 | AllFieldsSet = (TypeSet | DataSet) |
| 10474 | }; |
| 10475 | |
| 10476 | template<int STATE> |
| 10477 | class Builder { |
| 10478 | private: |
| 10479 | RefPtr<JSON::Object> m_result; |
| 10480 | |
| 10481 | template<int STEP> Builder<STATE | STEP>& castState() |
| 10482 | { |
| 10483 | return *reinterpret_cast<Builder<STATE | STEP>*>(this); |
| 10484 | } |
| 10485 | |
| 10486 | Builder(Ref</*TimelineEvent*/JSON::Object>&& object) |
| 10487 | : m_result(WTFMove(object)) |
| 10488 | { |
| 10489 | COMPILE_ASSERT(STATE == NoFieldsSet, builder_created_in_non_init_state); |
| 10490 | } |
| 10491 | friend class TimelineEvent; |
| 10492 | public: |
| 10493 | |
| 10494 | Builder<STATE | TypeSet>& setType(Protocol::Timeline::EventType in_type) |
| 10495 | { |
| 10496 | COMPILE_ASSERT(!(STATE & TypeSet), property_type_already_set); |
| 10497 | m_result->setString("type"_s , Protocol::Helpers::getEnumConstantValue(in_type)); |
| 10498 | return castState<TypeSet>(); |
| 10499 | } |
| 10500 | |
| 10501 | Builder<STATE | DataSet>& setData(Ref<JSON::Object>&& in_data) |
| 10502 | { |
| 10503 | COMPILE_ASSERT(!(STATE & DataSet), property_data_already_set); |
| 10504 | m_result->setObject("data"_s , WTFMove(in_data)); |
| 10505 | return castState<DataSet>(); |
| 10506 | } |
| 10507 | |
| 10508 | Ref<TimelineEvent> release() |
| 10509 | { |
| 10510 | COMPILE_ASSERT(STATE == AllFieldsSet, result_is_not_ready); |
| 10511 | COMPILE_ASSERT(sizeof(TimelineEvent) == sizeof(JSON::Object), cannot_cast); |
| 10512 | |
| 10513 | Ref<JSON::Object> jsonResult = m_result.releaseNonNull(); |
| 10514 | auto result = WTFMove(*reinterpret_cast<Ref<TimelineEvent>*>(&jsonResult)); |
| 10515 | return result; |
| 10516 | } |
| 10517 | }; |
| 10518 | |
| 10519 | /* |
| 10520 | * Synthetic constructor: |
| 10521 | * Ref<TimelineEvent> result = TimelineEvent::create() |
| 10522 | * .setType(...) |
| 10523 | * .setData(...) |
| 10524 | * .release(); |
| 10525 | */ |
| 10526 | static Builder<NoFieldsSet> create() |
| 10527 | { |
| 10528 | return Builder<NoFieldsSet>(JSON::Object::create()); |
| 10529 | } |
| 10530 | |
| 10531 | void setChildren(Ref<JSON::ArrayOf<Protocol::Timeline::TimelineEvent>>&& in_opt_children) |
| 10532 | { |
| 10533 | JSON::ObjectBase::setArray("children"_s , WTFMove(in_opt_children)); |
| 10534 | } |
| 10535 | |
| 10536 | // Property names for type generated as open. |
| 10537 | JS_EXPORT_PRIVATE static const ASCIILiteral typeKey; |
| 10538 | JS_EXPORT_PRIVATE static const ASCIILiteral dataKey; |
| 10539 | JS_EXPORT_PRIVATE static const ASCIILiteral childrenKey; |
| 10540 | }; |
| 10541 | |
| 10542 | } // Timeline |
| 10543 | |
| 10544 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Location> { |
| 10545 | static void assertValueHasExpectedType(JSON::Value*); |
| 10546 | }; |
| 10547 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::FunctionDetails> { |
| 10548 | static Ref<Protocol::Debugger::FunctionDetails> runtimeCast(Ref<JSON::Value>&& value); |
| 10549 | static void assertValueHasExpectedType(JSON::Value*); |
| 10550 | }; |
| 10551 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::CallFrame> { |
| 10552 | static Ref<Protocol::Debugger::CallFrame> runtimeCast(Ref<JSON::Value>&& value); |
| 10553 | static void assertValueHasExpectedType(JSON::Value*); |
| 10554 | }; |
| 10555 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Scope> { |
| 10556 | static void assertValueHasExpectedType(JSON::Value*); |
| 10557 | }; |
| 10558 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Debugger::Scope::Type> { |
| 10559 | static void assertValueHasExpectedType(JSON::Value*); |
| 10560 | }; |
| 10561 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject> { |
| 10562 | static Ref<Protocol::Runtime::RemoteObject> runtimeCast(Ref<JSON::Value>&& value); |
| 10563 | static void assertValueHasExpectedType(JSON::Value*); |
| 10564 | }; |
| 10565 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject::Type> { |
| 10566 | static void assertValueHasExpectedType(JSON::Value*); |
| 10567 | }; |
| 10568 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::RemoteObject::Subtype> { |
| 10569 | static void assertValueHasExpectedType(JSON::Value*); |
| 10570 | }; |
| 10571 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview> { |
| 10572 | static Ref<Protocol::Runtime::ObjectPreview> runtimeCast(Ref<JSON::Value>&& value); |
| 10573 | static void assertValueHasExpectedType(JSON::Value*); |
| 10574 | }; |
| 10575 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview::Type> { |
| 10576 | static void assertValueHasExpectedType(JSON::Value*); |
| 10577 | }; |
| 10578 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::ObjectPreview::Subtype> { |
| 10579 | static void assertValueHasExpectedType(JSON::Value*); |
| 10580 | }; |
| 10581 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview> { |
| 10582 | static void assertValueHasExpectedType(JSON::Value*); |
| 10583 | }; |
| 10584 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview::Type> { |
| 10585 | static void assertValueHasExpectedType(JSON::Value*); |
| 10586 | }; |
| 10587 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyPreview::Subtype> { |
| 10588 | static void assertValueHasExpectedType(JSON::Value*); |
| 10589 | }; |
| 10590 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::EntryPreview> { |
| 10591 | static void assertValueHasExpectedType(JSON::Value*); |
| 10592 | }; |
| 10593 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::CollectionEntry> { |
| 10594 | static Ref<Protocol::Runtime::CollectionEntry> runtimeCast(Ref<JSON::Value>&& value); |
| 10595 | static void assertValueHasExpectedType(JSON::Value*); |
| 10596 | }; |
| 10597 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::PropertyDescriptor> { |
| 10598 | static Ref<Protocol::Runtime::PropertyDescriptor> runtimeCast(Ref<JSON::Value>&& value); |
| 10599 | static void assertValueHasExpectedType(JSON::Value*); |
| 10600 | }; |
| 10601 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Runtime::InternalPropertyDescriptor> { |
| 10602 | static Ref<Protocol::Runtime::InternalPropertyDescriptor> runtimeCast(Ref<JSON::Value>&& value); |
| 10603 | static void assertValueHasExpectedType(JSON::Value*); |
| 10604 | }; |
| 10605 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Timeline::TimelineEvent> { |
| 10606 | static Ref<Protocol::Timeline::TimelineEvent> runtimeCast(Ref<JSON::Value>&& value); |
| 10607 | static void assertValueHasExpectedType(JSON::Value*); |
| 10608 | }; |
| 10609 | template<> struct JS_EXPORT_PRIVATE BindingTraits<Protocol::Timeline::EventType> { |
| 10610 | static void assertValueHasExpectedType(JSON::Value*); |
| 10611 | }; |
| 10612 | |
| 10613 | namespace Helpers { |
| 10614 | |
| 10615 | template<typename ProtocolEnumType> |
| 10616 | std::optional<ProtocolEnumType> parseEnumValueFromString(const String&); |
| 10617 | |
| 10618 | // Enums in the 'Animation' Domain |
| 10619 | template<> |
| 10620 | JS_EXPORT_PRIVATE std::optional<Protocol::Animation::AnimationState> parseEnumValueFromString<Protocol::Animation::AnimationState>(const String&); |
| 10621 | template<> |
| 10622 | JS_EXPORT_PRIVATE std::optional<Protocol::Animation::PlaybackDirection> parseEnumValueFromString<Protocol::Animation::PlaybackDirection>(const String&); |
| 10623 | template<> |
| 10624 | JS_EXPORT_PRIVATE std::optional<Protocol::Animation::FillMode> parseEnumValueFromString<Protocol::Animation::FillMode>(const String&); |
| 10625 | |
| 10626 | #if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 10627 | // Enums in the 'CPUProfiler' Domain |
| 10628 | template<> |
| 10629 | JS_EXPORT_PRIVATE std::optional<Protocol::CPUProfiler::ThreadInfo::Type> parseEnumValueFromString<Protocol::CPUProfiler::ThreadInfo::Type>(const String&); |
| 10630 | #endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 10631 | |
| 10632 | // Enums in the 'CSS' Domain |
| 10633 | template<> |
| 10634 | JS_EXPORT_PRIVATE std::optional<Protocol::CSS::StyleSheetOrigin> parseEnumValueFromString<Protocol::CSS::StyleSheetOrigin>(const String&); |
| 10635 | template<> |
| 10636 | JS_EXPORT_PRIVATE std::optional<Protocol::CSS::PseudoId> parseEnumValueFromString<Protocol::CSS::PseudoId>(const String&); |
| 10637 | template<> |
| 10638 | JS_EXPORT_PRIVATE std::optional<Protocol::CSS::CSSPropertyStatus> parseEnumValueFromString<Protocol::CSS::CSSPropertyStatus>(const String&); |
| 10639 | template<> |
| 10640 | JS_EXPORT_PRIVATE std::optional<Protocol::CSS::LayoutContextType> parseEnumValueFromString<Protocol::CSS::LayoutContextType>(const String&); |
| 10641 | template<> |
| 10642 | JS_EXPORT_PRIVATE std::optional<Protocol::CSS::LayoutContextTypeChangedMode> parseEnumValueFromString<Protocol::CSS::LayoutContextTypeChangedMode>(const String&); |
| 10643 | template<> |
| 10644 | JS_EXPORT_PRIVATE std::optional<Protocol::CSS::Grouping::Type> parseEnumValueFromString<Protocol::CSS::Grouping::Type>(const String&); |
| 10645 | |
| 10646 | // Enums in the 'Canvas' Domain |
| 10647 | template<> |
| 10648 | JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ContextType> parseEnumValueFromString<Protocol::Canvas::ContextType>(const String&); |
| 10649 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10650 | template<> |
| 10651 | JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ProgramType> parseEnumValueFromString<Protocol::Canvas::ProgramType>(const String&); |
| 10652 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10653 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10654 | template<> |
| 10655 | JS_EXPORT_PRIVATE std::optional<Protocol::Canvas::ShaderType> parseEnumValueFromString<Protocol::Canvas::ShaderType>(const String&); |
| 10656 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10657 | |
| 10658 | // Enums in the 'Console' Domain |
| 10659 | template<> |
| 10660 | JS_EXPORT_PRIVATE std::optional<Protocol::Console::ChannelSource> parseEnumValueFromString<Protocol::Console::ChannelSource>(const String&); |
| 10661 | template<> |
| 10662 | JS_EXPORT_PRIVATE std::optional<Protocol::Console::ChannelLevel> parseEnumValueFromString<Protocol::Console::ChannelLevel>(const String&); |
| 10663 | template<> |
| 10664 | JS_EXPORT_PRIVATE std::optional<Protocol::Console::ConsoleMessage::Level> parseEnumValueFromString<Protocol::Console::ConsoleMessage::Level>(const String&); |
| 10665 | template<> |
| 10666 | JS_EXPORT_PRIVATE std::optional<Protocol::Console::ConsoleMessage::Type> parseEnumValueFromString<Protocol::Console::ConsoleMessage::Type>(const String&); |
| 10667 | |
| 10668 | // Enums in the 'DOM' Domain |
| 10669 | template<> |
| 10670 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::PseudoType> parseEnumValueFromString<Protocol::DOM::PseudoType>(const String&); |
| 10671 | template<> |
| 10672 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::ShadowRootType> parseEnumValueFromString<Protocol::DOM::ShadowRootType>(const String&); |
| 10673 | template<> |
| 10674 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::CustomElementState> parseEnumValueFromString<Protocol::DOM::CustomElementState>(const String&); |
| 10675 | template<> |
| 10676 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::LiveRegionRelevant> parseEnumValueFromString<Protocol::DOM::LiveRegionRelevant>(const String&); |
| 10677 | template<> |
| 10678 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Checked> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Checked>(const String&); |
| 10679 | template<> |
| 10680 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Current> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Current>(const String&); |
| 10681 | template<> |
| 10682 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::Invalid> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::Invalid>(const String&); |
| 10683 | template<> |
| 10684 | JS_EXPORT_PRIVATE std::optional<Protocol::DOM::AccessibilityProperties::LiveRegionStatus> parseEnumValueFromString<Protocol::DOM::AccessibilityProperties::LiveRegionStatus>(const String&); |
| 10685 | |
| 10686 | // Enums in the 'DOMDebugger' Domain |
| 10687 | template<> |
| 10688 | JS_EXPORT_PRIVATE std::optional<Protocol::DOMDebugger::DOMBreakpointType> parseEnumValueFromString<Protocol::DOMDebugger::DOMBreakpointType>(const String&); |
| 10689 | template<> |
| 10690 | JS_EXPORT_PRIVATE std::optional<Protocol::DOMDebugger::EventBreakpointType> parseEnumValueFromString<Protocol::DOMDebugger::EventBreakpointType>(const String&); |
| 10691 | |
| 10692 | // Enums in the 'Debugger' Domain |
| 10693 | template<> |
| 10694 | JS_EXPORT_PRIVATE std::optional<Protocol::Debugger::BreakpointAction::Type> parseEnumValueFromString<Protocol::Debugger::BreakpointAction::Type>(const String&); |
| 10695 | template<> |
| 10696 | JS_EXPORT_PRIVATE std::optional<Protocol::Debugger::Scope::Type> parseEnumValueFromString<Protocol::Debugger::Scope::Type>(const String&); |
| 10697 | |
| 10698 | // Enums in the 'Heap' Domain |
| 10699 | template<> |
| 10700 | JS_EXPORT_PRIVATE std::optional<Protocol::Heap::GarbageCollection::Type> parseEnumValueFromString<Protocol::Heap::GarbageCollection::Type>(const String&); |
| 10701 | |
| 10702 | // Enums in the 'IndexedDB' Domain |
| 10703 | template<> |
| 10704 | JS_EXPORT_PRIVATE std::optional<Protocol::IndexedDB::Key::Type> parseEnumValueFromString<Protocol::IndexedDB::Key::Type>(const String&); |
| 10705 | template<> |
| 10706 | JS_EXPORT_PRIVATE std::optional<Protocol::IndexedDB::KeyPath::Type> parseEnumValueFromString<Protocol::IndexedDB::KeyPath::Type>(const String&); |
| 10707 | |
| 10708 | #if defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 10709 | // Enums in the 'Memory' Domain |
| 10710 | template<> |
| 10711 | JS_EXPORT_PRIVATE std::optional<Protocol::Memory::CategoryData::Type> parseEnumValueFromString<Protocol::Memory::CategoryData::Type>(const String&); |
| 10712 | #endif // defined(ENABLE_RESOURCE_USAGE) && ENABLE_RESOURCE_USAGE |
| 10713 | |
| 10714 | // Enums in the 'Network' Domain |
| 10715 | template<> |
| 10716 | JS_EXPORT_PRIVATE std::optional<Protocol::Network::NetworkStage> parseEnumValueFromString<Protocol::Network::NetworkStage>(const String&); |
| 10717 | template<> |
| 10718 | JS_EXPORT_PRIVATE std::optional<Protocol::Network::ResourceErrorType> parseEnumValueFromString<Protocol::Network::ResourceErrorType>(const String&); |
| 10719 | template<> |
| 10720 | JS_EXPORT_PRIVATE std::optional<Protocol::Network::Response::Source> parseEnumValueFromString<Protocol::Network::Response::Source>(const String&); |
| 10721 | template<> |
| 10722 | JS_EXPORT_PRIVATE std::optional<Protocol::Network::Metrics::Priority> parseEnumValueFromString<Protocol::Network::Metrics::Priority>(const String&); |
| 10723 | template<> |
| 10724 | JS_EXPORT_PRIVATE std::optional<Protocol::Network::Initiator::Type> parseEnumValueFromString<Protocol::Network::Initiator::Type>(const String&); |
| 10725 | |
| 10726 | // Enums in the 'Page' Domain |
| 10727 | template<> |
| 10728 | JS_EXPORT_PRIVATE std::optional<Protocol::Page::Setting> parseEnumValueFromString<Protocol::Page::Setting>(const String&); |
| 10729 | template<> |
| 10730 | JS_EXPORT_PRIVATE std::optional<Protocol::Page::ResourceType> parseEnumValueFromString<Protocol::Page::ResourceType>(const String&); |
| 10731 | template<> |
| 10732 | JS_EXPORT_PRIVATE std::optional<Protocol::Page::CoordinateSystem> parseEnumValueFromString<Protocol::Page::CoordinateSystem>(const String&); |
| 10733 | template<> |
| 10734 | JS_EXPORT_PRIVATE std::optional<Protocol::Page::CookieSameSitePolicy> parseEnumValueFromString<Protocol::Page::CookieSameSitePolicy>(const String&); |
| 10735 | #if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 10736 | template<> |
| 10737 | JS_EXPORT_PRIVATE std::optional<Protocol::Page::Appearance> parseEnumValueFromString<Protocol::Page::Appearance>(const String&); |
| 10738 | #endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 10739 | |
| 10740 | // Enums in the 'Recording' Domain |
| 10741 | template<> |
| 10742 | JS_EXPORT_PRIVATE std::optional<Protocol::Recording::Type> parseEnumValueFromString<Protocol::Recording::Type>(const String&); |
| 10743 | template<> |
| 10744 | JS_EXPORT_PRIVATE std::optional<Protocol::Recording::Initiator> parseEnumValueFromString<Protocol::Recording::Initiator>(const String&); |
| 10745 | |
| 10746 | // Enums in the 'Runtime' Domain |
| 10747 | template<> |
| 10748 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ExecutionContextType> parseEnumValueFromString<Protocol::Runtime::ExecutionContextType>(const String&); |
| 10749 | template<> |
| 10750 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::SyntaxErrorType> parseEnumValueFromString<Protocol::Runtime::SyntaxErrorType>(const String&); |
| 10751 | template<> |
| 10752 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::RemoteObject::Type> parseEnumValueFromString<Protocol::Runtime::RemoteObject::Type>(const String&); |
| 10753 | template<> |
| 10754 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::RemoteObject::Subtype> parseEnumValueFromString<Protocol::Runtime::RemoteObject::Subtype>(const String&); |
| 10755 | template<> |
| 10756 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ObjectPreview::Type> parseEnumValueFromString<Protocol::Runtime::ObjectPreview::Type>(const String&); |
| 10757 | template<> |
| 10758 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::ObjectPreview::Subtype> parseEnumValueFromString<Protocol::Runtime::ObjectPreview::Subtype>(const String&); |
| 10759 | template<> |
| 10760 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::PropertyPreview::Type> parseEnumValueFromString<Protocol::Runtime::PropertyPreview::Type>(const String&); |
| 10761 | template<> |
| 10762 | JS_EXPORT_PRIVATE std::optional<Protocol::Runtime::PropertyPreview::Subtype> parseEnumValueFromString<Protocol::Runtime::PropertyPreview::Subtype>(const String&); |
| 10763 | |
| 10764 | // Enums in the 'ScriptProfiler' Domain |
| 10765 | template<> |
| 10766 | JS_EXPORT_PRIVATE std::optional<Protocol::ScriptProfiler::EventType> parseEnumValueFromString<Protocol::ScriptProfiler::EventType>(const String&); |
| 10767 | |
| 10768 | // Enums in the 'Target' Domain |
| 10769 | template<> |
| 10770 | JS_EXPORT_PRIVATE std::optional<Protocol::Target::TargetInfo::Type> parseEnumValueFromString<Protocol::Target::TargetInfo::Type>(const String&); |
| 10771 | |
| 10772 | // Enums in the 'Timeline' Domain |
| 10773 | template<> |
| 10774 | JS_EXPORT_PRIVATE std::optional<Protocol::Timeline::EventType> parseEnumValueFromString<Protocol::Timeline::EventType>(const String&); |
| 10775 | template<> |
| 10776 | JS_EXPORT_PRIVATE std::optional<Protocol::Timeline::Instrument> parseEnumValueFromString<Protocol::Timeline::Instrument>(const String&); |
| 10777 | |
| 10778 | } // namespace Helpers |
| 10779 | |
| 10780 | } // namespace Protocol |
| 10781 | |
| 10782 | } // namespace Inspector |
| 10783 | |
| 10784 | namespace WTF { |
| 10785 | |
| 10786 | template<typename T> struct DefaultHash; |
| 10787 | |
| 10788 | // Hash declarations in the 'Animation' Domain |
| 10789 | template<> |
| 10790 | struct DefaultHash<Inspector::Protocol::Animation::AnimationState> : IntHash<Inspector::Protocol::Animation::AnimationState> { }; |
| 10791 | template<> |
| 10792 | struct DefaultHash<Inspector::Protocol::Animation::PlaybackDirection> : IntHash<Inspector::Protocol::Animation::PlaybackDirection> { }; |
| 10793 | template<> |
| 10794 | struct DefaultHash<Inspector::Protocol::Animation::FillMode> : IntHash<Inspector::Protocol::Animation::FillMode> { }; |
| 10795 | |
| 10796 | // Hash declarations in the 'CSS' Domain |
| 10797 | template<> |
| 10798 | struct DefaultHash<Inspector::Protocol::CSS::StyleSheetOrigin> : IntHash<Inspector::Protocol::CSS::StyleSheetOrigin> { }; |
| 10799 | template<> |
| 10800 | struct DefaultHash<Inspector::Protocol::CSS::PseudoId> : IntHash<Inspector::Protocol::CSS::PseudoId> { }; |
| 10801 | template<> |
| 10802 | struct DefaultHash<Inspector::Protocol::CSS::CSSPropertyStatus> : IntHash<Inspector::Protocol::CSS::CSSPropertyStatus> { }; |
| 10803 | template<> |
| 10804 | struct DefaultHash<Inspector::Protocol::CSS::LayoutContextType> : IntHash<Inspector::Protocol::CSS::LayoutContextType> { }; |
| 10805 | template<> |
| 10806 | struct DefaultHash<Inspector::Protocol::CSS::LayoutContextTypeChangedMode> : IntHash<Inspector::Protocol::CSS::LayoutContextTypeChangedMode> { }; |
| 10807 | |
| 10808 | // Hash declarations in the 'Canvas' Domain |
| 10809 | template<> |
| 10810 | struct DefaultHash<Inspector::Protocol::Canvas::ContextType> : IntHash<Inspector::Protocol::Canvas::ContextType> { }; |
| 10811 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10812 | template<> |
| 10813 | struct DefaultHash<Inspector::Protocol::Canvas::ProgramType> : IntHash<Inspector::Protocol::Canvas::ProgramType> { }; |
| 10814 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10815 | #if (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10816 | template<> |
| 10817 | struct DefaultHash<Inspector::Protocol::Canvas::ShaderType> : IntHash<Inspector::Protocol::Canvas::ShaderType> { }; |
| 10818 | #endif // (defined(ENABLE_WEBGL) && ENABLE_WEBGL) || (defined(ENABLE_WEBGPU) && ENABLE_WEBGPU) |
| 10819 | |
| 10820 | // Hash declarations in the 'Console' Domain |
| 10821 | template<> |
| 10822 | struct DefaultHash<Inspector::Protocol::Console::ChannelSource> : IntHash<Inspector::Protocol::Console::ChannelSource> { }; |
| 10823 | template<> |
| 10824 | struct DefaultHash<Inspector::Protocol::Console::ChannelLevel> : IntHash<Inspector::Protocol::Console::ChannelLevel> { }; |
| 10825 | |
| 10826 | // Hash declarations in the 'DOM' Domain |
| 10827 | template<> |
| 10828 | struct DefaultHash<Inspector::Protocol::DOM::PseudoType> : IntHash<Inspector::Protocol::DOM::PseudoType> { }; |
| 10829 | template<> |
| 10830 | struct DefaultHash<Inspector::Protocol::DOM::ShadowRootType> : IntHash<Inspector::Protocol::DOM::ShadowRootType> { }; |
| 10831 | template<> |
| 10832 | struct DefaultHash<Inspector::Protocol::DOM::CustomElementState> : IntHash<Inspector::Protocol::DOM::CustomElementState> { }; |
| 10833 | template<> |
| 10834 | struct DefaultHash<Inspector::Protocol::DOM::LiveRegionRelevant> : IntHash<Inspector::Protocol::DOM::LiveRegionRelevant> { }; |
| 10835 | |
| 10836 | // Hash declarations in the 'DOMDebugger' Domain |
| 10837 | template<> |
| 10838 | struct DefaultHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> : IntHash<Inspector::Protocol::DOMDebugger::DOMBreakpointType> { }; |
| 10839 | template<> |
| 10840 | struct DefaultHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> : IntHash<Inspector::Protocol::DOMDebugger::EventBreakpointType> { }; |
| 10841 | |
| 10842 | // Hash declarations in the 'Network' Domain |
| 10843 | template<> |
| 10844 | struct DefaultHash<Inspector::Protocol::Network::NetworkStage> : IntHash<Inspector::Protocol::Network::NetworkStage> { }; |
| 10845 | template<> |
| 10846 | struct DefaultHash<Inspector::Protocol::Network::ResourceErrorType> : IntHash<Inspector::Protocol::Network::ResourceErrorType> { }; |
| 10847 | |
| 10848 | // Hash declarations in the 'Page' Domain |
| 10849 | template<> |
| 10850 | struct DefaultHash<Inspector::Protocol::Page::Setting> : IntHash<Inspector::Protocol::Page::Setting> { }; |
| 10851 | template<> |
| 10852 | struct DefaultHash<Inspector::Protocol::Page::ResourceType> : IntHash<Inspector::Protocol::Page::ResourceType> { }; |
| 10853 | template<> |
| 10854 | struct DefaultHash<Inspector::Protocol::Page::CoordinateSystem> : IntHash<Inspector::Protocol::Page::CoordinateSystem> { }; |
| 10855 | template<> |
| 10856 | struct DefaultHash<Inspector::Protocol::Page::CookieSameSitePolicy> : IntHash<Inspector::Protocol::Page::CookieSameSitePolicy> { }; |
| 10857 | #if (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 10858 | template<> |
| 10859 | struct DefaultHash<Inspector::Protocol::Page::Appearance> : IntHash<Inspector::Protocol::Page::Appearance> { }; |
| 10860 | #endif // (defined(ENABLE_DARK_MODE_CSS) && ENABLE_DARK_MODE_CSS) || (defined(HAVE_OS_DARK_MODE_SUPPORT) && HAVE_OS_DARK_MODE_SUPPORT) |
| 10861 | |
| 10862 | // Hash declarations in the 'Recording' Domain |
| 10863 | template<> |
| 10864 | struct DefaultHash<Inspector::Protocol::Recording::Type> : IntHash<Inspector::Protocol::Recording::Type> { }; |
| 10865 | template<> |
| 10866 | struct DefaultHash<Inspector::Protocol::Recording::Initiator> : IntHash<Inspector::Protocol::Recording::Initiator> { }; |
| 10867 | |
| 10868 | // Hash declarations in the 'Runtime' Domain |
| 10869 | template<> |
| 10870 | struct DefaultHash<Inspector::Protocol::Runtime::ExecutionContextType> : IntHash<Inspector::Protocol::Runtime::ExecutionContextType> { }; |
| 10871 | template<> |
| 10872 | struct DefaultHash<Inspector::Protocol::Runtime::SyntaxErrorType> : IntHash<Inspector::Protocol::Runtime::SyntaxErrorType> { }; |
| 10873 | |
| 10874 | // Hash declarations in the 'ScriptProfiler' Domain |
| 10875 | template<> |
| 10876 | struct DefaultHash<Inspector::Protocol::ScriptProfiler::EventType> : IntHash<Inspector::Protocol::ScriptProfiler::EventType> { }; |
| 10877 | |
| 10878 | // Hash declarations in the 'Timeline' Domain |
| 10879 | template<> |
| 10880 | struct DefaultHash<Inspector::Protocol::Timeline::EventType> : IntHash<Inspector::Protocol::Timeline::EventType> { }; |
| 10881 | template<> |
| 10882 | struct DefaultHash<Inspector::Protocol::Timeline::Instrument> : IntHash<Inspector::Protocol::Timeline::Instrument> { }; |
| 10883 | |
| 10884 | } // namespace WTF |
| 10885 | |